Upload 63 files

.dockerignore

@@ -0,0 +1,68 @@
+# Exclure les environnements virtuels
+.venv/
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Python cache
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.pyc
+*.pyw
+*.pyz
+
+# OS / IDE files
+.DS_Store
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Git
+.git/
+.gitignore
+
+# Logs & temp
+*.log
+*.tmp
+*.temp
+.cache/
+tmp/
+
+# Données et résultats intermédiaires
+input/
+output/
+*.zip
+*.png
+*.jpg
+*.jpeg
+*.npy
+*.pkl
+*.h5
+*.pth
+*.pt
+
+# Fichiers spécifiques à ton projet
+data/private/
+UnderstandScripts/
+env_test/
+requirements_copy.txt
+requirements_clean.txt
+
+# Vercel & Docker fichiers
+.vercel/
+Dockerfile
+docker-compose.yml
+.dockerignore
+
+# Vidéos
+*.mp4
+
+
+
+models/

.gitignore

@@ -0,0 +1,109 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+.venv/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Temporary files
+*.tmp
+*.temp
+.cache/
+tmp/
+
+# Data files (si sensibles)
+data/private/
+*.pkl
+*.h5
+
+# Model files (si trop gros)
+*.pth
+*.pt
+
+
+# Environment variables
+.env.local
+.env.production
+
+# Jupyter
+.ipynb_checkpoints/
+
+# pytest
+.pytest_cache/
+
+# Coverage
+htmlcov/
+.coverage
+.coverage.*
+
+# Docker (optionnel selon votre besoin)
+# Dockerfile
+# .dockerignore
+
+# Vercel
+.vercel
+
+input/
+output/
+*.zip
+*.png
+*.jpg
+*.npy
+
+UnderstandScripts/
+inference/
+models/
+
+env_test/
+
+requirements_copy.txt
+
+requirements_clean.txt
+

Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+CMD ["uvicorn", "api:app", "--host", "0.0.0.0", "--port", "8000"]

LICENSE

@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

PnLCalib.yml

@@ -0,0 +1,235 @@
+name: PnLCalib
+channels:
+  - pytorch
+  - nvidia
+  - conda-forge
+  - defaults
+dependencies:
+  - _libgcc_mutex=0.1=conda_forge
+  - _openmp_mutex=4.5=2_kmp_llvm
+  - alsa-lib=1.2.8=h166bdaf_0
+  - attr=2.5.1=h166bdaf_1
+  - blas=2.116=mkl
+  - blas-devel=3.9.0=16_linux64_mkl
+  - brotli=1.1.0=hd590300_1
+  - brotli-bin=1.1.0=hd590300_1
+  - brotli-python=1.1.0=py39h3d6467e_1
+  - bzip2=1.0.8=hd590300_5
+  - ca-certificates=2024.6.2=hbcca054_0
+  - cairo=1.16.0=ha61ee94_1014
+  - certifi=2024.6.2=pyhd8ed1ab_0
+  - cffi=1.16.0=py39h7a31438_0
+  - charset-normalizer=3.3.2=pyhd8ed1ab_0
+  - colorama=0.4.6=pyhd8ed1ab_0
+  - contourpy=1.2.1=py39h7633fee_0
+  - cuda-cudart=12.1.105=0
+  - cuda-cupti=12.1.105=0
+  - cuda-libraries=12.1.0=0
+  - cuda-nvrtc=12.1.105=0
+  - cuda-nvtx=12.1.105=0
+  - cuda-opencl=12.5.39=0
+  - cuda-runtime=12.1.0=0
+  - cuda-version=12.5=3
+  - cycler=0.12.1=pyhd8ed1ab_0
+  - dbus=1.13.6=h5008d03_3
+  - expat=2.6.2=h59595ed_0
+  - ffmpeg=4.3=hf484d3e_0
+  - fftw=3.3.10=nompi_hf1063bd_110
+  - filelock=3.15.4=pyhd8ed1ab_0
+  - font-ttf-dejavu-sans-mono=2.37=hab24e00_0
+  - font-ttf-inconsolata=3.000=h77eed37_0
+  - font-ttf-source-code-pro=2.038=h77eed37_0
+  - font-ttf-ubuntu=0.83=h77eed37_2
+  - fontconfig=2.14.2=h14ed4e7_0
+  - fonts-conda-ecosystem=1=0
+  - fonts-conda-forge=1=0
+  - fonttools=4.53.0=py39hd3abc70_0
+  - freetype=2.12.1=h267a509_2
+  - geos=3.12.1=h59595ed_0
+  - gettext=0.22.5=h59595ed_2
+  - gettext-tools=0.22.5=h59595ed_2
+  - glib=2.80.2=hf974151_0
+  - glib-tools=2.80.2=hb6ce0ca_0
+  - gmp=6.3.0=hac33072_2
+  - gmpy2=2.1.5=py39h048c657_1
+  - gnutls=3.6.13=h85f3911_1
+  - graphite2=1.3.13=h59595ed_1003
+  - gst-plugins-base=1.22.0=h4243ec0_2
+  - gstreamer=1.22.0=h25f0c4b_2
+  - gstreamer-orc=0.4.38=hd590300_0
+  - h2=4.1.0=pyhd8ed1ab_0
+  - harfbuzz=6.0.0=h8e241bc_0
+  - hpack=4.0.0=pyh9f0ad1d_0
+  - hyperframe=6.0.1=pyhd8ed1ab_0
+  - icu=70.1=h27087fc_0
+  - idna=3.7=pyhd8ed1ab_0
+  - importlib-resources=6.4.0=pyhd8ed1ab_0
+  - importlib_resources=6.4.0=pyhd8ed1ab_0
+  - jack=1.9.22=h11f4161_0
+  - jinja2=3.1.4=pyhd8ed1ab_0
+  - jpeg=9e=h166bdaf_2
+  - keyutils=1.6.1=h166bdaf_0
+  - kiwisolver=1.4.5=py39h7633fee_1
+  - krb5=1.20.1=h81ceb04_0
+  - lame=3.100=h166bdaf_1003
+  - lcms2=2.15=hfd0df8a_0
+  - ld_impl_linux-64=2.40=hf3520f5_7
+  - lerc=4.0.0=h27087fc_0
+  - libasprintf=0.22.5=h661eb56_2
+  - libasprintf-devel=0.22.5=h661eb56_2
+  - libblas=3.9.0=16_linux64_mkl
+  - libbrotlicommon=1.1.0=hd590300_1
+  - libbrotlidec=1.1.0=hd590300_1
+  - libbrotlienc=1.1.0=hd590300_1
+  - libcap=2.67=he9d0100_0
+  - libcblas=3.9.0=16_linux64_mkl
+  - libclang=15.0.7=default_h127d8a8_5
+  - libclang13=15.0.7=default_h5d6823c_5
+  - libcublas=12.1.0.26=0
+  - libcufft=11.0.2.4=0
+  - libcufile=1.10.0.4=0
+  - libcups=2.3.3=h36d4200_3
+  - libcurand=10.3.6.39=0
+  - libcusolver=11.4.4.55=0
+  - libcusparse=12.0.2.55=0
+  - libdb=6.2.32=h9c3ff4c_0
+  - libdeflate=1.17=h0b41bf4_0
+  - libedit=3.1.20191231=he28a2e2_2
+  - libevent=2.1.10=h28343ad_4
+  - libexpat=2.6.2=h59595ed_0
+  - libffi=3.4.2=h7f98852_5
+  - libflac=1.4.3=h59595ed_0
+  - libgcc-ng=14.1.0=h77fa898_0
+  - libgcrypt=1.11.0=h4ab18f5_0
+  - libgettextpo=0.22.5=h59595ed_2
+  - libgettextpo-devel=0.22.5=h59595ed_2
+  - libgfortran-ng=14.1.0=h69a702a_0
+  - libgfortran5=14.1.0=hc5f4f2c_0
+  - libglib=2.80.2=hf974151_0
+  - libgomp=14.1.0=h77fa898_0
+  - libgpg-error=1.50=h4f305b6_0
+  - libhwloc=2.9.1=hd6dc26d_0
+  - libiconv=1.17=hd590300_2
+  - libjpeg-turbo=2.0.0=h9bf148f_0
+  - liblapack=3.9.0=16_linux64_mkl
+  - liblapacke=3.9.0=16_linux64_mkl
+  - libllvm15=15.0.7=hadd5161_1
+  - libnpp=12.0.2.50=0
+  - libnsl=2.0.1=hd590300_0
+  - libnvjitlink=12.1.105=0
+  - libnvjpeg=12.1.1.14=0
+  - libogg=1.3.5=h4ab18f5_0
+  - libopus=1.3.1=h7f98852_1
+  - libpng=1.6.43=h2797004_0
+  - libpq=15.3=hbcd7760_1
+  - libsndfile=1.2.2=hc60ed4a_1
+  - libsqlite=3.46.0=hde9e2c9_0
+  - libstdcxx-ng=14.1.0=hc0a3c3a_0
+  - libsystemd0=253=h8c4010b_1
+  - libtiff=4.5.0=h6adf6a1_2
+  - libtool=2.4.7=h27087fc_0
+  - libudev1=253=h0b41bf4_1
+  - libuuid=2.38.1=h0b41bf4_0
+  - libvorbis=1.3.7=h9c3ff4c_0
+  - libwebp-base=1.4.0=hd590300_0
+  - libxcb=1.13=h7f98852_1004
+  - libxcrypt=4.4.36=hd590300_1
+  - libxkbcommon=1.5.0=h79f4944_1
+  - libxml2=2.10.3=hca2bb57_4
+  - libzlib=1.2.13=h4ab18f5_6
+  - llvm-openmp=15.0.7=h0cdce71_0
+  - lz4-c=1.9.4=hcb278e6_0
+  - markupsafe=2.1.5=py39hd1e30aa_0
+  - matplotlib=3.8.4=py39hf3d152e_2
+  - matplotlib-base=3.8.4=py39h10d1fc8_2
+  - mkl=2022.1.0=h84fe81f_915
+  - mkl-devel=2022.1.0=ha770c72_916
+  - mkl-include=2022.1.0=h84fe81f_915
+  - mpc=1.3.1=hfe3b2da_0
+  - mpfr=4.2.1=h9458935_1
+  - mpg123=1.32.6=h59595ed_0
+  - mpmath=1.3.0=pyhd8ed1ab_0
+  - munkres=1.1.4=pyh9f0ad1d_0
+  - mysql-common=8.0.33=hf1915f5_6
+  - mysql-libs=8.0.33=hca2cd23_6
+  - ncurses=6.5=h59595ed_0
+  - nettle=3.6=he412f7d_0
+  - networkx=3.2.1=pyhd8ed1ab_0
+  - nspr=4.35=h27087fc_0
+  - nss=3.100=hca3bf56_0
+  - numpy=2.0.0=py39ha0965c0_0
+  - openh264=2.1.1=h780b84a_0
+  - openjpeg=2.5.0=hfec8fc6_2
+  - openssl=3.1.6=h4ab18f5_0
+  - packaging=24.1=pyhd8ed1ab_0
+  - pcre2=10.43=hcad00b1_0
+  - pillow=9.4.0=py39h2320bf1_1
+  - pip=24.0=pyhd8ed1ab_0
+  - pixman=0.43.2=h59595ed_0
+  - ply=3.11=pyhd8ed1ab_2
+  - pthread-stubs=0.4=h36c2ea0_1001
+  - pulseaudio=16.1=hcb278e6_3
+  - pulseaudio-client=16.1=h5195f5e_3
+  - pulseaudio-daemon=16.1=ha8d29e2_3
+  - pycparser=2.22=pyhd8ed1ab_0
+  - pyparsing=3.1.2=pyhd8ed1ab_0
+  - pyqt=5.15.9=py39h52134e7_5
+  - pyqt5-sip=12.12.2=py39h3d6467e_5
+  - pysocks=1.7.1=pyha2e5f31_6
+  - python=3.9.18=h0755675_0_cpython
+  - python-dateutil=2.9.0=pyhd8ed1ab_0
+  - python_abi=3.9=4_cp39
+  - pytorch=2.3.1=py3.9_cuda12.1_cudnn8.9.2_0
+  - pytorch-cuda=12.1=ha16c6d3_5
+  - pytorch-mutex=1.0=cuda
+  - pyyaml=6.0.1=py39hd1e30aa_1
+  - qt-main=5.15.8=h5d23da1_6
+  - readline=8.2=h8228510_1
+  - requests=2.32.3=pyhd8ed1ab_0
+  - setuptools=70.1.1=pyhd8ed1ab_0
+  - shapely=2.0.4=py39h5a575da_1
+  - sip=6.7.12=py39h3d6467e_0
+  - six=1.16.0=pyh6c4a22f_0
+  - sympy=1.12.1=pypyh2585a3b_103
+  - tbb=2021.9.0=hf52228f_0
+  - tk=8.6.13=noxft_h4845f30_101
+  - toml=0.10.2=pyhd8ed1ab_0
+  - tomli=2.0.1=pyhd8ed1ab_0
+  - torchaudio=2.3.1=py39_cu121
+  - torchtriton=2.3.1=py39
+  - torchvision=0.18.1=py39_cu121
+  - tornado=6.4.1=py39hd3abc70_0
+  - tqdm=4.66.4=pyhd8ed1ab_0
+  - typing_extensions=4.12.2=pyha770c72_0
+  - tzdata=2024a=h0c530f3_0
+  - unicodedata2=15.1.0=py39hd1e30aa_0
+  - urllib3=2.2.2=pyhd8ed1ab_1
+  - wheel=0.43.0=pyhd8ed1ab_1
+  - xcb-util=0.4.0=h516909a_0
+  - xcb-util-image=0.4.0=h166bdaf_0
+  - xcb-util-keysyms=0.4.0=h516909a_0
+  - xcb-util-renderutil=0.3.9=h166bdaf_0
+  - xcb-util-wm=0.4.1=h516909a_0
+  - xkeyboard-config=2.38=h0b41bf4_0
+  - xorg-kbproto=1.0.7=h7f98852_1002
+  - xorg-libice=1.1.1=hd590300_0
+  - xorg-libsm=1.2.4=h7391055_0
+  - xorg-libx11=1.8.4=h0b41bf4_0
+  - xorg-libxau=1.0.11=hd590300_0
+  - xorg-libxdmcp=1.1.3=h7f98852_0
+  - xorg-libxext=1.3.4=h0b41bf4_2
+  - xorg-libxrender=0.9.10=h7f98852_1003
+  - xorg-renderproto=0.11.1=h7f98852_1002
+  - xorg-xextproto=7.3.0=h0b41bf4_1003
+  - xorg-xproto=7.0.31=h7f98852_1007
+  - xz=5.2.6=h166bdaf_0
+  - yaml=0.2.5=h7f98852_2
+  - zipp=3.19.2=pyhd8ed1ab_0
+  - zlib=1.2.13=h4ab18f5_6
+  - zstandard=0.22.0=py39h81c9582_1
+  - zstd=1.5.6=ha6fb4c9_0
+  - pip:
+      - lsq-ellipse==2.2.1
+      - opencv-python==4.10.0.84
+      - scipy==1.13.1
+prefix: /home/mgutierrez/anaconda3/envs/PnLCalib

README.md

@@ -1,10 +1,134 @@
----
-title: PnLCalib
-emoji: 🚀
-colorFrom: purple
-colorTo: red
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# PnLCalib API
+
+> API REST pour la calibration de caméras à partir de lignes de terrain de football
+
+## À propos de ce projet
+
+Cette API est basée sur le travail de recherche original de **SoccerNet Camera Calibration Challenge**. Elle transforme les algorithmes de calibration existants en une API REST accessible et facile à utiliser.
+
+### Travail original
+📍 **Repository source** : [SoccerNet Camera Calibration](https://github.com/SoccerNet/sn-calibration)  [Marc Gutiérrez-Pérez](https://github.com/mguti97/PnLCalib)
+📖 **Paper** : SoccerNet Camera Calibration Challenge  
+👥 **Auteurs** : Équipe SoccerNet
+
+## Fonctionnalités
+
+✅ Calibration automatique de caméras à partir d'images de terrain de football  
+✅ API REST avec FastAPI  
+✅ Support des formats d'image : JPG, PNG  
+
+## Installation locale
+
+```bash
+# Cloner le repository
+git clone https://github.com/2nzi/PnLCalib.git
+cd PnLCalib
+
+# Installer les dépendances
+pip install -r requirements.txt
+
+# Lancer l'API
+python run_api.py
+```
+
+L'API sera accessible sur : http://localhost:8000
+
+## Utilisation
+
+### Endpoint principal : `/calibrate`
+
+**POST** `/calibrate` - Calibrer une caméra à partir d'une image et de lignes du terrain
+
+**Paramètres :**
+- `image` : Fichier image (multipart/form-data)
+- `lines_data` : JSON des lignes du terrain (string)
+
+### Exemple d'utilisation
+
+#### Avec JavaScript/Fetch
+```javascript
+const formData = new FormData();
+formData.append('image', imageFile);
+formData.append('lines_data', JSON.stringify({
+    "Big rect. right top": [
+        {"x": 1342.88, "y": 1076.99},
+        {"x": 1484.74, "y": 906.37}
+    ],
+    "Big rect. right main": [
+        {"x": 1484.74, "y": 906.37},
+        {"x": 1049.62, "y": 748.02}
+    ],
+    "Circle central": [
+        {"x": 1580.73, "y": 269.84},
+        {"x": 1533.83, "y": 288.86}
+    ]
+    // ... autres lignes
+}));
+
+const response = await fetch('http://localhost:8000/calibrate', {
+    method: 'POST',
+    body: formData
+});
+
+const result = await response.json();
+console.log('Paramètres de calibration:', result.camera_parameters);
+```
+
+#### Avec curl
+```bash
+curl -X POST "http://localhost:8000/calibrate" \
+  -F "[email protected]" \
+  -F 'lines_data={"Big rect. right top":[{"x":1342.88,"y":1076.99}]}'
+```
+
+### Format de réponse
+
+```json
+{
+  "status": "success",
+  "camera_parameters": {
+    "pan_degrees": -45.2,
+    "tilt_degrees": 12.8,
+    "roll_degrees": 1.2,
+    "position_meters": [10.5, 20.3, 5.8],
+    "x_focal_length": 1200.5,
+    "y_focal_length": 1201.2,
+    "principal_point": [960, 540]
+  },
+  "input_lines": { /* lignes validées */ },
+  "message": "Calibration réussie"
+}
+```
+
+## Documentation
+
+Une fois l'API lancée, accédez à la documentation interactive :
+- **Swagger UI** : http://localhost:8000/docs
+- **ReDoc** : http://localhost:8000/redoc
+
+## Health Check
+
+```bash
+curl http://localhost:8000/health
+```
+
+## Support des lignes de terrain
+
+L'API accepte ces types de lignes de terrain :
+- `Big rect. right/left top/main/bottom`
+- `Small rect. right/left top/main`
+- `Circle right/left/central`
+- `Side line bottom/left`
+- `Middle line`
+...
+
+Chaque ligne est définie par une liste de points avec coordonnées `x` et `y`.
+
+## Crédits
+
+Basé sur le travail original de l'équipe SoccerNet pour le Camera Calibration Challenge [Marc Gutiérrez-Pérez](https://github.com/mguti97/PnLCalib).  
+Transformé en API REST par [2nzi](https://github.com/2nzi).
+
+## Licence
+
+Voir [LICENSE](LICENSE) - Basé sur la licence du projet original SoccerNet.

api.py

@@ -0,0 +1,162 @@
+from fastapi import FastAPI, HTTPException, UploadFile, File, Form
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Dict, List, Any
+import json
+import tempfile
+import os
+from PIL import Image
+import numpy as np
+
+from get_camera_params import get_camera_parameters
+
+app = FastAPI(
+    title="Football Vision Calibration API",
+    description="API pour la calibration de caméras à partir de lignes de terrain de football",
+    version="1.0.0"
+)
+
+# Configuration CORS pour autoriser les requêtes depuis le frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # En production, spécifiez les domaines autorisés
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Modèles Pydantic pour la validation des données
+class Point(BaseModel):
+    x: float
+    y: float
+
+class LinePolygon(BaseModel):
+    points: List[Point]
+
+class CalibrationRequest(BaseModel):
+    lines: Dict[str, List[Point]]
+
+class CalibrationResponse(BaseModel):
+    status: str
+    camera_parameters: Dict[str, Any]
+    input_lines: Dict[str, List[Point]]
+    message: str
+
+@app.get("/")
+async def root():
+    return {
+        "message": "Football Vision Calibration API", 
+        "version": "1.0.0",
+        "endpoints": {
+            "/calibrate": "POST - Calibrer une caméra à partir d'une image et de lignes",
+            "/health": "GET - Vérifier l'état de l'API"
+        }
+    }
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "message": "API is running"}
+
+@app.post("/calibrate", response_model=CalibrationResponse)
+async def calibrate_camera(
+    image: UploadFile = File(..., description="Image du terrain de football"),
+    lines_data: str = Form(..., description="JSON des lignes du terrain")
+):
+    """
+    Calibrer une caméra à partir d'une image et des lignes du terrain.
+    
+    Args:
+        image: Image du terrain de football (formats: jpg, jpeg, png)
+        lines_data: JSON contenant les lignes du terrain au format:
+                   {"nom_ligne": [{"x": float, "y": float}, ...], ...}
+    
+    Returns:
+        Paramètres de calibration de la caméra et lignes d'entrée
+    """
+    try:
+        # Validation du format d'image
+        if not image.content_type.startswith('image/'):
+            raise HTTPException(status_code=400, detail="Le fichier doit être une image")
+        
+        # Parse des données de lignes
+        try:
+            lines_dict = json.loads(lines_data)
+        except json.JSONDecodeError:
+            raise HTTPException(status_code=400, detail="Format JSON invalide pour les lignes")
+        
+        # Validation de la structure des lignes
+        validated_lines = {}
+        for line_name, points in lines_dict.items():
+            if not isinstance(points, list):
+                raise HTTPException(
+                    status_code=400, 
+                    detail=f"Les points de la ligne '{line_name}' doivent être une liste"
+                )
+            
+            validated_points = []
+            for i, point in enumerate(points):
+                if not isinstance(point, dict) or 'x' not in point or 'y' not in point:
+                    raise HTTPException(
+                        status_code=400,
+                        detail=f"Point {i} de la ligne '{line_name}' doit avoir les clés 'x' et 'y'"
+                    )
+                try:
+                    validated_points.append({
+                        "x": float(point['x']),
+                        "y": float(point['y'])
+                    })
+                except (ValueError, TypeError):
+                    raise HTTPException(
+                        status_code=400,
+                        detail=f"Coordonnées invalides pour le point {i} de la ligne '{line_name}'"
+                    )
+            
+            validated_lines[line_name] = validated_points
+        
+        # Sauvegarde temporaire de l'image
+        with tempfile.NamedTemporaryFile(delete=False, suffix=f".{image.filename.split('.')[-1]}") as temp_file:
+            content = await image.read()
+            temp_file.write(content)
+            temp_image_path = temp_file.name
+        
+        try:
+            # Validation de l'image
+            pil_image = Image.open(temp_image_path)
+            pil_image.verify()  # Vérification de l'intégrité de l'image
+            
+            # Calibration de la caméra
+            camera_params = get_camera_parameters(temp_image_path, validated_lines)
+            
+            # Formatage de la réponse
+            response = CalibrationResponse(
+                status="success",
+                camera_parameters=camera_params,
+                input_lines=validated_lines,
+                message="Calibration réussie"
+            )
+            
+            return response
+            
+        except Exception as e:
+            raise HTTPException(
+                status_code=500, 
+                detail=f"Erreur lors de la calibration: {str(e)}"
+            )
+        
+        finally:
+            # Nettoyage du fichier temporaire
+            if os.path.exists(temp_image_path):
+                os.unlink(temp_image_path)
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erreur interne: {str(e)}")
+
+# if __name__ == "__main__":
+#     import uvicorn
+#     uvicorn.run(app, host="0.0.0.0", port=8000)
+
+# Ajoutez ceci à la place :
+# Point d'entrée pour Vercel
+app_instance = app

config.yaml

@@ -0,0 +1,33 @@
+# config.yaml
+# weights_kp: "models/SV_FT_TSWC_kp"
+# weights_line: "models/SV_FT_TSWC_lines"
+# pnl_refine: true
+# device: "cuda:0"
+# input_path: "examples/input/"
+# output_path: "examples/output/"
+# name: "FootDrone.jpg"
+# input_type: "image"
+# display: true
+
+# # Start with low thresholds
+# thresholds:
+#   - kp_threshold: 0.15
+#     line_threshold: 0.15
+
+
+weights_kp: "models/SV_FT_TSWC_kp"
+weights_line: "models/SV_FT_TSWC_lines"
+device: "cuda:0"
+input_path: "examples/input/"
+output_path: "examples/output/"
+name: "FootDrone.mp4"
+input_type: "video"
+display: true
+pnl_refine: true
+frame_step: 5  # Traiter une image sur 5
+two_pass: true 
+
+# Start with low thresholds
+thresholds:
+  - kp_threshold: 0.15
+    line_threshold: 0.15

config/field_config.py

@@ -0,0 +1,164 @@
+"""
+Configuration file for football field elements (lines and keypoints)
+All measurements are in meters
+Field dimensions: 105m x 68m
+Origin (0,0) is at top-left corner
+"""
+
+# Lines configuration
+LINES = {
+    1: {"name": "Big rect. left bottom", "description": "Surface de réparation gauche - ligne basse"},
+    2: {"name": "Big rect. left main", "description": "Surface de réparation gauche - ligne parallèle"},
+    3: {"name": "Big rect. left top", "description": "Surface de réparation gauche - ligne haute"},
+    4: {"name": "Big rect. right bottom", "description": "Surface de réparation droite - ligne basse"},
+    5: {"name": "Big rect. right main", "description": "Surface de réparation droite - ligne parallèle"},
+    6: {"name": "Big rect. right top", "description": "Surface de réparation droite - ligne haute"},
+    7: {"name": "Goal left crossbar", "description": "Barre transversale but gauche"},
+    8: {"name": "Goal left post left", "description": "Poteau gauche but gauche"},
+    9: {"name": "Goal left post right", "description": "Poteau droit but gauche"},
+    10: {"name": "Goal right crossbar", "description": "Barre transversale but droit"},
+    11: {"name": "Goal right post left", "description": "Poteau gauche but droit"},
+    12: {"name": "Goal right post right", "description": "Poteau droit but droit"},
+    13: {"name": "Middle line", "description": "Ligne médiane"},
+    14: {"name": "Side line bottom", "description": "Ligne de but"},
+    15: {"name": "Side line left", "description": "Ligne de touche gauche"},
+    16: {"name": "Side line right", "description": "Ligne de touche droite"},
+    17: {"name": "Side line top", "description": "Ligne de but opposée"},
+    18: {"name": "Small rect. left bottom", "description": "Petite surface gauche - ligne basse"},
+    19: {"name": "Small rect. left main", "description": "Petite surface gauche - ligne parallèle"},
+    20: {"name": "Small rect. left top", "description": "Petite surface gauche - ligne haute"},
+    21: {"name": "Small rect. right bottom", "description": "Petite surface droite - ligne basse"},
+    22: {"name": "Small rect. right main", "description": "Petite surface droite - ligne parallèle"},
+    23: {"name": "Small rect. right top", "description": "Petite surface droite - ligne haute"}
+}
+
+# Keypoints configuration
+KEYPOINTS = {
+    # Points principaux (1-30)
+    1: {"name": "Top Left Corner", "coords": [0.0, 0.0], "description": "Coin supérieur gauche"},
+    2: {"name": "Top Middle", "coords": [52.5, 0.0], "description": "Milieu ligne du haut"},
+    3: {"name": "Top Right Corner", "coords": [105.0, 0.0], "description": "Coin supérieur droit"},
+    4: {"name": "Left Big Box Top", "coords": [0.0, 16.5], "description": "Surface gauche haut"},
+    5: {"name": "Left Big Box Main", "coords": [16.5, 16.5], "description": "Surface gauche principale"},
+    6: {"name": "Right Big Box Main", "coords": [88.5, 16.5], "description": "Surface droite principale"},
+    7: {"name": "Right Big Box Top", "coords": [105.0, 16.5], "description": "Surface droite haut"},
+    8: {"name": "Left Small Box Top", "coords": [0.0, 5.5], "description": "Petite surface gauche haut"},
+    9: {"name": "Left Small Box Main", "coords": [5.5, 5.5], "description": "Petite surface gauche principale"},
+    10: {"name": "Right Small Box Main", "coords": [99.5, 5.5], "description": "Petite surface droite principale"},
+    11: {"name": "Right Small Box Top", "coords": [105.0, 5.5], "description": "Petite surface droite haut"},
+    12: {"name": "Left Goal Crossbar Right", "coords": [3.66, 0.0], "description": "Barre transversale gauche - droite"},
+    13: {"name": "Left Goal Post Right", "coords": [3.66, 2.44], "description": "Poteau droit but gauche"},
+    14: {"name": "Right Goal Post Left", "coords": [101.34, 2.44], "description": "Poteau gauche but droit"},
+    15: {"name": "Right Goal Crossbar Left", "coords": [101.34, 0.0], "description": "Barre transversale droite - gauche"},
+    16: {"name": "Left Goal Crossbar Left", "coords": [0.0, 0.0], "description": "Barre transversale gauche - gauche"},
+    17: {"name": "Left Goal Post Left", "coords": [0.0, 2.44], "description": "Poteau gauche but gauche"},
+    18: {"name": "Right Goal Post Right", "coords": [105.0, 2.44], "description": "Poteau droit but droit"},
+    19: {"name": "Right Goal Crossbar Right", "coords": [105.0, 0.0], "description": "Barre transversale droite - droite"},
+    20: {"name": "Left Small Box Bottom", "coords": [0.0, 0.0], "description": "Petite surface gauche bas"},
+    21: {"name": "Left Small Box Bottom Main", "coords": [5.5, 0.0], "description": "Petite surface gauche bas principale"},
+    22: {"name": "Right Small Box Bottom Main", "coords": [99.5, 0.0], "description": "Petite surface droite bas principale"},
+    23: {"name": "Right Small Box Bottom", "coords": [105.0, 0.0], "description": "Petite surface droite bas"},
+    24: {"name": "Left Big Box Bottom", "coords": [0.0, 0.0], "description": "Surface gauche bas"},
+    25: {"name": "Bottom Middle", "coords": [52.5, 0.0], "description": "Milieu ligne du bas"},
+    26: {"name": "Right Big Box Bottom", "coords": [105.0, 0.0], "description": "Surface droite bas"},
+    27: {"name": "Left Big Box Bottom Main", "coords": [16.5, 0.0], "description": "Surface gauche bas principale"},
+    28: {"name": "Bottom Middle Top", "coords": [52.5, 68.0], "description": "Milieu ligne opposée"},
+    29: {"name": "Right Big Box Bottom Main", "coords": [88.5, 0.0], "description": "Surface droite bas principale"},
+    30: {"name": "Left Penalty Spot", "coords": [11.0, 34.0], "description": "Point de penalty gauche"},
+
+    # Points auxiliaires (31-57)
+    31: {"name": "Left Box Aux 1", "coords": [16.5, 20.0], "description": "Point auxiliaire surface gauche 1"},
+    32: {"name": "Center Circle Left", "coords": [43.35, 34.0], "description": "Rond central gauche"},
+    33: {"name": "Center Circle Right", "coords": [61.65, 34.0], "description": "Rond central droit"},
+    34: {"name": "Right Box Aux 1", "coords": [88.5, 20.0], "description": "Point auxiliaire surface droite 1"},
+    35: {"name": "Left Box Aux 2", "coords": [16.5, 48.0], "description": "Point auxiliaire surface gauche 2"},
+    36: {"name": "Right Box Aux 2", "coords": [88.5, 48.0], "description": "Point auxiliaire surface droite 2"},
+    37: {"name": "Center Circle Top Left", "coords": [43.35, 24.85], "description": "Rond central haut gauche"},
+    38: {"name": "Center Circle Top Right", "coords": [61.65, 24.85], "description": "Rond central haut droit"},
+    39: {"name": "Center Circle Bottom Left", "coords": [43.35, 43.15], "description": "Rond central bas gauche"},
+    40: {"name": "Center Circle Bottom Right", "coords": [61.65, 43.15], "description": "Rond central bas droit"},
+    41: {"name": "Center Circle Left Inner", "coords": [46.03, 34.0], "description": "Rond central intérieur gauche"},
+    42: {"name": "Center Circle Right Inner", "coords": [58.97, 34.0], "description": "Rond central intérieur droit"},
+    43: {"name": "Center Circle Top Inner", "coords": [52.5, 27.53], "description": "Rond central intérieur haut"},
+    44: {"name": "Center Circle Bottom Inner", "coords": [52.5, 40.47], "description": "Rond central intérieur bas"},
+    45: {"name": "Left Penalty Arc Left", "coords": [19.99, 32.29], "description": "Arc penalty gauche - point gauche"},
+    46: {"name": "Left Penalty Arc Right", "coords": [19.99, 35.71], "description": "Arc penalty gauche - point droit"},
+    47: {"name": "Right Penalty Arc Left", "coords": [85.01, 32.29], "description": "Arc penalty droit - point gauche"},
+    48: {"name": "Right Penalty Arc Right", "coords": [85.01, 35.71], "description": "Arc penalty droit - point droit"},
+    49: {"name": "Left Penalty Arc Top", "coords": [16.5, 34.0], "description": "Arc penalty gauche - point haut"},
+    50: {"name": "Right Penalty Arc Top", "coords": [88.5, 34.0], "description": "Arc penalty droit - point haut"},
+    51: {"name": "Left Penalty Area Center", "coords": [16.5, 34.0], "description": "Centre surface de réparation gauche"},
+    52: {"name": "Right Penalty Area Center", "coords": [88.5, 34.0], "description": "Centre surface de réparation droite"},
+    53: {"name": "Right Penalty Spot", "coords": [94.0, 34.0], "description": "Point de penalty droit"},
+    54: {"name": "Center Spot", "coords": [52.5, 34.0], "description": "Point central"},
+    55: {"name": "Left Box Center", "coords": [16.5, 34.0], "description": "Centre surface gauche"},
+    56: {"name": "Right Box Center", "coords": [88.5, 34.0], "description": "Centre surface droite"},
+    57: {"name": "Center Circle Center", "coords": [52.5, 34.0], "description": "Centre rond central"}
+}
+
+# Field dimensions
+FIELD_DIMENSIONS = {
+    "length": 105.0,  # meters
+    "width": 68.0,    # meters
+    "center_circle_radius": 9.15,
+    "penalty_area_length": 16.5,
+    "penalty_area_width": 40.32,
+    "goal_area_length": 5.5,
+    "goal_area_width": 18.32,
+    "penalty_spot_dist": 11.0,
+    "goal_height": 2.44,
+    "goal_width": 7.32
+}
+
+# Line intersections that form keypoints
+KEYPOINT_LINE_PAIRS = [
+    ["Side line top", "Side line left"],
+    ["Side line top", "Middle line"],
+    ["Side line right", "Side line top"],
+    ["Side line left", "Big rect. left top"],
+    ["Big rect. left top", "Big rect. left main"],
+    ["Big rect. right top", "Big rect. right main"],
+    ["Side line right", "Big rect. right top"],
+    ["Side line left", "Small rect. left top"],
+    ["Small rect. left top", "Small rect. left main"],
+    ["Small rect. right top", "Small rect. right main"],
+    ["Side line right", "Small rect. right top"],
+    ["Goal left crossbar", "Goal left post right"],
+    ["Side line left", "Goal left post right"],
+    ["Side line right", "Goal right post left"],
+    ["Goal right crossbar", "Goal right post left"],
+    ["Goal left crossbar", "Goal left post left"],
+    ["Side line left", "Goal left post left"],
+    ["Side line right", "Goal right post right"],
+    ["Goal right crossbar", "Goal right post right"],
+    ["Side line left", "Small rect. left bottom"],
+    ["Small rect. left bottom", "Small rect. left main"],
+    ["Small rect. right bottom", "Small rect. right main"],
+    ["Side line right", "Small rect. right bottom"],
+    ["Side line left", "Big rect. left bottom"],
+    ["Big rect. left bottom", "Big rect. left main"],
+    ["Big rect. right bottom", "Big rect. right main"],
+    ["Side line right", "Big rect. right bottom"],
+    ["Side line left", "Side line bottom"],
+    ["Side line right", "Side line bottom"]
+]
+
+# Auxiliary keypoint pairs
+KEYPOINT_AUX_PAIRS = [
+    ["Small rect. left main", "Side line top"],
+    ["Big rect. left main", "Side line top"],
+    ["Big rect. right main", "Side line top"],
+    ["Small rect. right main", "Side line top"],
+    ["Small rect. left main", "Big rect. left top"],
+    ["Big rect. right top", "Small rect. right main"],
+    ["Small rect. left top", "Big rect. left main"],
+    ["Small rect. right top", "Big rect. right main"],
+    ["Small rect. left bottom", "Big rect. left main"],
+    ["Small rect. right bottom", "Big rect. right main"],
+    ["Small rect. left main", "Big rect. left bottom"],
+    ["Small rect. right main", "Big rect. right bottom"],
+    ["Small rect. left main", "Side line bottom"],
+    ["Big rect. left main", "Side line bottom"],
+    ["Big rect. right main", "Side line bottom"],
+    ["Small rect. right main", "Side line bottom"]
+] 

config/hrnetv2_w48.yaml

@@ -0,0 +1,35 @@
+MODEL:
+  IMAGE_SIZE: [960, 540]
+  NUM_JOINTS: 58
+  PRETRAIN: ''
+  EXTRA:
+    FINAL_CONV_KERNEL: 1
+    STAGE1:
+      NUM_MODULES: 1
+      NUM_BRANCHES: 1
+      BLOCK: BOTTLENECK
+      NUM_BLOCKS: [4]
+      NUM_CHANNELS: [64]
+      FUSE_METHOD: SUM
+    STAGE2:
+      NUM_MODULES: 1
+      NUM_BRANCHES: 2
+      BLOCK: BASIC
+      NUM_BLOCKS: [4, 4]
+      NUM_CHANNELS: [48, 96]
+      FUSE_METHOD: SUM
+    STAGE3:
+      NUM_MODULES: 4
+      NUM_BRANCHES: 3
+      BLOCK: BASIC
+      NUM_BLOCKS: [4, 4, 4]
+      NUM_CHANNELS: [48, 96, 192]
+      FUSE_METHOD: SUM
+    STAGE4:
+      NUM_MODULES: 3
+      NUM_BRANCHES: 4
+      BLOCK: BASIC
+      NUM_BLOCKS: [4, 4, 4, 4]
+      NUM_CHANNELS: [48, 96, 192, 384]
+      FUSE_METHOD: SUM
+

config/hrnetv2_w48_l.yaml

@@ -0,0 +1,35 @@
+MODEL:
+  IMAGE_SIZE: [960, 540]
+  NUM_JOINTS: 24
+  PRETRAIN: ''
+  EXTRA:
+    FINAL_CONV_KERNEL: 1
+    STAGE1:
+      NUM_MODULES: 1
+      NUM_BRANCHES: 1
+      BLOCK: BOTTLENECK
+      NUM_BLOCKS: [4]
+      NUM_CHANNELS: [64]
+      FUSE_METHOD: SUM
+    STAGE2:
+      NUM_MODULES: 1
+      NUM_BRANCHES: 2
+      BLOCK: BASIC
+      NUM_BLOCKS: [4, 4]
+      NUM_CHANNELS: [48, 96]
+      FUSE_METHOD: SUM
+    STAGE3:
+      NUM_MODULES: 4
+      NUM_BRANCHES: 3
+      BLOCK: BASIC
+      NUM_BLOCKS: [4, 4, 4]
+      NUM_CHANNELS: [48, 96, 192]
+      FUSE_METHOD: SUM
+    STAGE4:
+      NUM_MODULES: 3
+      NUM_BRANCHES: 4
+      BLOCK: BASIC
+      NUM_BLOCKS: [4, 4, 4, 4]
+      NUM_CHANNELS: [48, 96, 192, 384]
+      FUSE_METHOD: SUM
+

data/__init__.py

@@ -0,0 +1 @@
+# Fichier vide pour marquer le dossier comme un package Python 

data/line_data.py

@@ -0,0 +1,115 @@
+# Contient cam1_line_dict et cam3_line_dict 
+
+cam1_line_dict = {
+    "Side line top": [
+        {"x": 0, "y": 205.35510086780727},
+        {"x": 226.69196710942427, "y": 218.52089231566922},
+        {"x": 609.2346616065778, "y": 235.73769651671947},
+        {"x": 1072.7387729285256, "y": 248.90348796458142},
+        {"x": 1642.5047438330162, "y": 257.005513470958},
+        {"x": 1918.7855787476271, "y": 257.005513470958}
+    ],
+    "Big rect. right top": [
+        {"x": 1918.6823296329553, "y": 327.02322511812105},
+        {"x": 1761.8195845349164, "y": 327.02322511812105}
+    ],
+    "Big rect. right main": [
+        {"x": 1761.8195845349164, "y": 327.02322511812105},
+        {"x": 1774.5760335197388, "y": 409.7284234765342},
+        {"x": 1790.8194197631253, "y": 526.9377258021154},
+        {"x": 1809.8670388107444, "y": 671.5805829449724}
+    ],
+    "Big rect. right bottom": [
+        {"x": 1809.8670388107444, "y": 671.5805829449724},
+        {"x": 1917.4300640208282, "y": 677.1868952373312}
+    ],
+    "Circle right": [
+        {"x": 1774.5760335197388, "y": 409.7284234765342},
+        {"x": 1709.2165563955555, "y": 410.6005164997901},
+        {"x": 1629.0422644565579, "y": 423.6819118486273},
+        {"x": 1576.7546827572116, "y": 442.8679583602552},
+        {"x": 1568.0400858073206, "y": 459.43772580211566},
+        {"x": 1592.4409572670156, "y": 482.11214440676673},
+        {"x": 1698.7590400556867, "y": 511.7633071974644},
+        {"x": 1790.8194197631253, "y": 526.9377258021154}
+    ],
+    "Middle line": [
+        {"x": 0, "y": 308.65587267083185},
+        {"x": 226.69196710942427, "y": 218.52089231566922}
+    ],
+    "Circle central": [
+        {"x": 0, "y": 340.8997444495873},
+        {"x": 122.94647588765228, "y": 351.0820197481417},
+        {"x": 234.87016428192882, "y": 366.3554326959732},
+        {"x": 305.2464228934815, "y": 390.1140750592667},
+        {"x": 309.48595654477987, "y": 413.8727174225603},
+        {"x": 228.08691043985144, "y": 441.0254515520386},
+        {"x": 71.22416534181235, "y": 463.08704803223975},
+        {"x": 4.239533651298354, "y": 468.1781856815169}
+    ],
+    "Side line bottom": [
+        {"x": 1.3071895424836595, "y": 814.522819727929},
+        {"x": 636.6013071895421, "y": 827.6042150767662},
+        {"x": 1286.2745098039209, "y": 852.458866239557},
+        {"x": 1918.954248366012, "y": 889.086773216301}
+    ]
+}
+
+cam3_line_dict = {
+    "Big rect. right top": [
+        {"x": 1342.8861505076343, "y": 1076.997434976179},
+        {"x": 1484.7446330310781, "y": 906.3705391217808}
+    ],
+    "Big rect. right main": [
+        {"x": 1484.7446330310781, "y": 906.3705391217808},
+        {"x": 1049.6210183678218, "y": 748.0287797688992},
+        {"x": 828.6491513601493, "y": 668.8579000924583},
+        {"x": 349.8767728435256, "y": 500.9610345717304},
+        {"x": 32.736572890025556, "y": 397.21988189225624}
+    ],
+    "Big rect. right bottom": [
+        {"x": 32.736572890025556, "y": 397.21988189225624},
+        {"x": 0.3753980224568448, "y": 407.0286292126068}
+    ],
+    "Small rect. right top": [
+        {"x": 312.24913494809687, "y": 1075.6461846681693},
+        {"x": 426.66666666666663, "y": 999.9279904137233}
+    ],
+    "Small rect. right main": [
+        {"x": 426.66666666666663, "y": 999.9279904137233},
+        {"x": 0, "y": 769.079837198949}
+    ],
+    "Circle right": [
+        {"x": 828.6491513601493, "y": 668.8579000924583},
+        {"x": 821.7759602949911, "y": 612.2830792373484},
+        {"x": 782.8739995106773, "y": 564.5621490047902},
+        {"x": 722.6387053930304, "y": 529.3993583071158},
+        {"x": 623.5014504910696, "y": 503.02726528386006},
+        {"x": 494.24654853028534, "y": 492.980753655953},
+        {"x": 349.8767728435256, "y": 500.9610345717304}
+    ],
+    "Side line bottom": [
+        {"x": 2.0193824656299317, "y": 266.2605192109321},
+        {"x": 399.0443993689428, "y": 186.14824976426013},
+        {"x": 645.5533017804819, "y": 132.93313314748357},
+        {"x": 1001.1088573360372, "y": 53.39824942655338},
+        {"x": 1208.1676808654488, "y": 7.351737798646435}
+    ],
+    "Middle line": [
+        {"x": 645.5533017804819, "y": 132.93313314748357},
+        {"x": 1106.0585089650835, "y": 200.22939899146556},
+        {"x": 1580.7388158704541, "y": 269.8451725000601},
+        {"x": 1917.6527118636336, "y": 318.9857185061268}
+    ],
+    "Circle central": [
+        {"x": 1580.7388158704541, "y": 269.8451725000601},
+        {"x": 1580.7388158704541, "y": 269.8451725000601},
+        {"x": 1533.8366024891266, "y": 288.8643838246303},
+        {"x": 1441.810458698277, "y": 302.46903498742097},
+        {"x": 1316.3202626198458, "y": 304.5620582432349},
+        {"x": 1219.0653606590615, "y": 292.0039187083512},
+        {"x": 1135.4052299401073, "y": 274.2132210339326},
+        {"x": 1069.522876998931, "y": 237.5853140571884},
+        {"x": 1106.0585089650835, "y": 200.22939899146556}
+    ]
+} 

get_camera_params.py

@@ -0,0 +1,201 @@
+from utils.utils_keypoints import KeypointsDB
+from utils.utils_lines import LineKeypointsDB
+from utils.utils_calib import FramebyFrameCalib
+from utils.utils_heatmap import complete_keypoints
+from PIL import Image
+import torch
+import numpy as np
+
+# Données de lignes pour cam3
+cam3_line_dict = {
+    "Big rect. right top": [
+        {"x": 1342.8861505076343, "y": 1076.997434976179},
+        {"x": 1484.7446330310781, "y": 906.3705391217808}
+    ],
+    "Big rect. right main": [
+        {"x": 1484.7446330310781, "y": 906.3705391217808},
+        {"x": 1049.6210183678218, "y": 748.0287797688992},
+        {"x": 828.6491513601493, "y": 668.8579000924583},
+        {"x": 349.8767728435256, "y": 500.9610345717304},
+        {"x": 32.736572890025556, "y": 397.21988189225624}
+    ],
+    "Big rect. right bottom": [
+        {"x": 32.736572890025556, "y": 397.21988189225624},
+        {"x": 0.3753980224568448, "y": 407.0286292126068}
+    ],
+    "Small rect. right top": [
+        {"x": 312.24913494809687, "y": 1075.6461846681693},
+        {"x": 426.66666666666663, "y": 999.9279904137233}
+    ],
+    "Small rect. right main": [
+        {"x": 426.66666666666663, "y": 999.9279904137233},
+        {"x": 0, "y": 769.079837198949}
+    ],
+    "Circle right": [
+        {"x": 828.6491513601493, "y": 668.8579000924583},
+        {"x": 821.7759602949911, "y": 612.2830792373484},
+        {"x": 782.8739995106773, "y": 564.5621490047902},
+        {"x": 722.6387053930304, "y": 529.3993583071158},
+        {"x": 623.5014504910696, "y": 503.02726528386006},
+        {"x": 494.24654853028534, "y": 492.980753655953},
+        {"x": 349.8767728435256, "y": 500.9610345717304}
+    ],
+    "Side line bottom": [
+        {"x": 2.0193824656299317, "y": 266.2605192109321},
+        {"x": 399.0443993689428, "y": 186.14824976426013},
+        {"x": 645.5533017804819, "y": 132.93313314748357},
+        {"x": 1001.1088573360372, "y": 53.39824942655338},
+        {"x": 1208.1676808654488, "y": 7.351737798646435}
+    ],
+    "Middle line": [
+        {"x": 645.5533017804819, "y": 132.93313314748357},
+        {"x": 1106.0585089650835, "y": 200.22939899146556},
+        {"x": 1580.7388158704541, "y": 269.8451725000601},
+        {"x": 1917.6527118636336, "y": 318.9857185061268}
+    ],
+    "Circle central": [
+        {"x": 1580.7388158704541, "y": 269.8451725000601},
+        {"x": 1580.7388158704541, "y": 269.8451725000601},
+        {"x": 1533.8366024891266, "y": 288.8643838246303},
+        {"x": 1441.810458698277, "y": 302.46903498742097},
+        {"x": 1316.3202626198458, "y": 304.5620582432349},
+        {"x": 1219.0653606590615, "y": 292.0039187083512},
+        {"x": 1135.4052299401073, "y": 274.2132210339326},
+        {"x": 1069.522876998931, "y": 237.5853140571884},
+        {"x": 1106.0585089650835, "y": 200.22939899146556},
+        {"x": 1139.5882364760548, "y": 189.4457791734675},
+        {"x": 1224.2941188289963, "y": 177.9341512664908},
+        {"x": 1314.2287593518718, "y": 174.79461638276985},
+        {"x": 1392.6601319008914, "y": 180.02717452230473},
+        {"x": 1465.8627462799764, "y": 190.49229080137454},
+        {"x": 1529.6535959531789, "y": 204.09694196416518},
+        {"x": 1581.9411776525253, "y": 230.2597326618396},
+        {"x": 1580.7388158704541, "y": 269.8451725000601}
+    ],
+    "Side line left": [
+        {"x": 1208.1676808654488, "y": 7.351737798646435},
+        {"x": 1401.9652021886754, "y": 20.565213248502545},
+        {"x": 1582.3573590514204, "y": 30.37625976013045},
+        {"x": 1679.416182580832, "y": 34.300678364781604},
+        {"x": 1824.5142217965183, "y": 41.23091697692868},
+        {"x": 1918.6318688553417, "y": 42.21202162809147}
+    ],
+    "Big rect. left bottom": [
+        {"x": 1401.9652021886754, "y": 20.565213248502545},
+        {"x": 1283.3377512082834, "y": 53.98527744204496}
+    ],
+    "Big rect. left main": [
+        {"x": 1283.3377512082834, "y": 53.98527744204496},
+        {"x": 1510.7887316004399, "y": 73.60737046530076},
+        {"x": 1808.8279472867146, "y": 94.21056813971936},
+        {"x": 1918.6318688553417, "y": 100.0971960466961}
+    ],
+    "Circle left": [
+        {"x": 1510.7887316004399, "y": 73.60737046530076},
+        {"x": 1548.0436335612244, "y": 86.36173093041702},
+        {"x": 1620.5926531690673, "y": 95.19167279088215},
+        {"x": 1681.3769668945574, "y": 97.15388209320773},
+        {"x": 1746.0828492474989, "y": 100.0971960466961},
+        {"x": 1808.8279472867146, "y": 94.21056813971936}
+    ],
+    "Small rect. left bottom": [
+        {"x": 1550.9848100318127, "y": 42.21202162809147},
+        {"x": 1582.3573590514204, "y": 30.37625976013045}
+    ],
+    "Small rect. left main": [
+        {"x": 1550.9848100318127, "y": 42.21202162809147},
+        {"x": 1918.418689198772, "y": 60.49417894940041}
+    ]
+}
+
+def transform_data(line_dict, width, height):
+    """
+    Transform input line dictionary to normalized coordinates.
+    """
+    transformed = {}
+    for line_name, points in line_dict.items():
+        transformed[line_name] = []
+        for point in points:
+            transformed[line_name].append({
+                "x": point["x"] / width,
+                "y": point["y"] / height
+            })
+    return transformed
+
+def get_camera_parameters(image_path, line_dict):
+    """
+    Extract camera parameters from image and line data.
+    
+    Args:
+        image_path (str): Path to the image file
+        line_dict (dict): Dictionary containing line coordinates
+        
+    Returns:
+        dict: Camera parameters
+    """
+    # Load image
+    image = Image.open(image_path)
+    image_tensor = torch.FloatTensor(np.array(image)).permute(2, 0, 1)
+    
+    # Get image dimensions
+    img_width, img_height = image.size
+    
+    # Transform data using actual image dimensions
+    trans_data = transform_data(line_dict, img_width, img_height)
+    
+    # Initialize databases
+    kp_db = KeypointsDB(trans_data, image_tensor)
+    ln_db = LineKeypointsDB(trans_data, image_tensor)
+    
+    # Get keypoints and lines
+    kp_db.get_full_keypoints()
+    ln_db.get_lines()
+    
+    kp_dict = kp_db.keypoints_final
+    ln_dict = ln_db.lines
+    
+    # Complete keypoints
+    kp_dict, ln_dict = complete_keypoints(kp_dict, ln_dict, img_width, img_height)
+    
+    # Initialize calibration
+    cam = FramebyFrameCalib(img_width, img_height)
+    cam.update(kp_dict, ln_dict)
+    cam_params = cam.heuristic_voting(refine_lines=True)
+    
+    return cam_params
+
+def main():
+    # Chemin vers votre image
+    image_path = "examples/input/cam3.jpg"
+    
+    # Obtenir les paramètres de la caméra
+    camera_params = get_camera_parameters(image_path, cam3_line_dict)
+    
+    # Afficher les paramètres
+    print("=== PARAMÈTRES DE LA CAMÉRA ===")
+    print(f"Position (mètres): {camera_params['cam_params']['position_meters']}")
+    print(f"Distance focale X: {camera_params['cam_params']['x_focal_length']:.2f}")
+    print(f"Distance focale Y: {camera_params['cam_params']['y_focal_length']:.2f}")
+    print(f"Point principal: {camera_params['cam_params']['principal_point']}")
+    print(f"Matrice de rotation:")
+    rotation_matrix = np.array(camera_params['cam_params']['rotation_matrix'])
+    print(rotation_matrix)
+    
+    # Calcul des angles d'Euler
+    euler_angles = np.array([
+        np.arctan2(rotation_matrix[2,1], rotation_matrix[2,2]),  # roll
+        np.arctan2(-rotation_matrix[2,0], np.sqrt(rotation_matrix[2,1]**2 + rotation_matrix[2,2]**2)),  # pitch
+        np.arctan2(rotation_matrix[1,0], rotation_matrix[0,0])   # yaw
+    ]) * 180 / np.pi
+    
+    print(f"Angles d'Euler (degrés):")
+    print(f"  Roll: {euler_angles[0]:.1f}°")
+    print(f"  Pitch: {euler_angles[1]:.1f}°")
+    print(f"  Yaw: {euler_angles[2]:.1f}°")
+
+    # print(camera_params)
+    
+    return camera_params
+
+if __name__ == "__main__":
+    main() 

inference.py

@@ -0,0 +1,286 @@
+import cv2
+import yaml
+import torch
+import argparse
+import numpy as np
+import matplotlib.pyplot as plt
+import torchvision.transforms as T
+import torchvision.transforms.functional as f
+
+from tqdm import tqdm
+from PIL import Image
+from matplotlib.patches import Polygon
+
+from model.cls_hrnet import get_cls_net
+from model.cls_hrnet_l import get_cls_net as get_cls_net_l
+
+from utils.utils_calib import FramebyFrameCalib, pan_tilt_roll_to_orientation
+from utils.utils_heatmap import get_keypoints_from_heatmap_batch_maxpool, get_keypoints_from_heatmap_batch_maxpool_l, \
+    complete_keypoints, coords_to_dict
+
+
+lines_coords = [[[0., 54.16, 0.], [16.5, 54.16, 0.]],
+                [[16.5, 13.84, 0.], [16.5, 54.16, 0.]],
+                [[16.5, 13.84, 0.], [0., 13.84, 0.]],
+                [[88.5, 54.16, 0.], [105., 54.16, 0.]],
+                [[88.5, 13.84, 0.], [88.5, 54.16, 0.]],
+                [[88.5, 13.84, 0.], [105., 13.84, 0.]],
+                [[0., 37.66, -2.44], [0., 30.34, -2.44]],
+                [[0., 37.66, 0.], [0., 37.66, -2.44]],
+                [[0., 30.34, 0.], [0., 30.34, -2.44]],
+                [[105., 37.66, -2.44], [105., 30.34, -2.44]],
+                [[105., 30.34, 0.], [105., 30.34, -2.44]],
+                [[105., 37.66, 0.], [105., 37.66, -2.44]],
+                [[52.5, 0., 0.], [52.5, 68, 0.]],
+                [[0., 68., 0.], [105., 68., 0.]],
+                [[0., 0., 0.], [0., 68., 0.]],
+                [[105., 0., 0.], [105., 68., 0.]],
+                [[0., 0., 0.], [105., 0., 0.]],
+                [[0., 43.16, 0.], [5.5, 43.16, 0.]],
+                [[5.5, 43.16, 0.], [5.5, 24.84, 0.]],
+                [[5.5, 24.84, 0.], [0., 24.84, 0.]],
+                [[99.5, 43.16, 0.], [105., 43.16, 0.]],
+                [[99.5, 43.16, 0.], [99.5, 24.84, 0.]],
+                [[99.5, 24.84, 0.], [105., 24.84, 0.]]]
+
+
+def projection_from_cam_params(final_params_dict):
+    cam_params = final_params_dict["cam_params"]
+    x_focal_length = cam_params['x_focal_length']
+    y_focal_length = cam_params['y_focal_length']
+    principal_point = np.array(cam_params['principal_point'])
+    position_meters = np.array(cam_params['position_meters'])
+    rotation = np.array(cam_params['rotation_matrix'])
+
+    It = np.eye(4)[:-1]
+    It[:, -1] = -position_meters
+    Q = np.array([[x_focal_length, 0, principal_point[0]],
+                  [0, y_focal_length, principal_point[1]],
+                  [0, 0, 1]])
+    P = Q @ (rotation @ It)
+
+    return P
+
+
+def inference(cam, frame, model, model_l, kp_threshold, line_threshold, pnl_refine):
+    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+    frame = Image.fromarray(frame)
+
+    frame = f.to_tensor(frame).float().unsqueeze(0)
+    _, _, h_original, w_original = frame.size()
+    frame = frame if frame.size()[-1] == 960 else transform2(frame)
+    frame = frame.to(device)
+    b, c, h, w = frame.size()
+
+    with torch.no_grad():
+        heatmaps = model(frame)
+        heatmaps_l = model_l(frame)
+
+    kp_coords = get_keypoints_from_heatmap_batch_maxpool(heatmaps[:,:-1,:,:])
+    # print("\n"*4,"kp_coords: ", kp_coords)
+    line_coords = get_keypoints_from_heatmap_batch_maxpool_l(heatmaps_l[:,:-1,:,:])
+    print("\n"*4,"line_coords_from_heatmap: ", line_coords)
+    kp_dict = coords_to_dict(kp_coords, threshold=kp_threshold)
+    lines_dict = coords_to_dict(line_coords, threshold=line_threshold)
+    
+    # print("\n=== AVANT complete_keypoints ===")
+    # print("--- KEYPOINTS ---")
+    # print(f"Nombre de keypoints: {len(kp_dict[0])}")
+    # print("Structure des keypoints:")
+    for kp_key, kp_value in kp_dict[0].items():
+        print(f"{kp_key}: {kp_value}")
+
+    # print("\n--- LIGNES ---")
+    # print(f"Nombre de lignes: {len(lines_dict[0])}")
+    # print("Structure des lignes:")
+    for line_key, line_value in lines_dict[0].items():
+        print(f"{line_key}: {line_value}")
+
+    kp_dict, lines_dict = complete_keypoints(kp_dict[0], lines_dict[0], w=w, h=h, normalize=True)
+
+    # print("\n=== APRÈS complete_keypoints ===")
+    # print("--- KEYPOINTS ---")
+    # print(f"Nombre de keypoints: {len(kp_dict)}")
+    # print("Structure des keypoints:")
+    for kp_key, kp_value in kp_dict.items():
+        print(f"{kp_key}: {kp_value}")
+
+    # print("\n--- LIGNES ---")
+    # print(f"Nombre de lignes: {len(lines_dict)}")
+    # print("Structure des lignes:")
+    for line_key, line_value in lines_dict.items():
+        print(f"{line_key}: {line_value}")
+
+    cam.update(kp_dict, lines_dict)
+    final_params_dict = cam.heuristic_voting(refine_lines=pnl_refine)
+
+    return final_params_dict
+
+
+def project(frame, P):
+
+    for line in lines_coords:
+        w1 = line[0]
+        w2 = line[1]
+        i1 = P @ np.array([w1[0]-105/2, w1[1]-68/2, w1[2], 1])
+        i2 = P @ np.array([w2[0]-105/2, w2[1]-68/2, w2[2], 1])
+        i1 /= i1[-1]
+        i2 /= i2[-1]
+        frame = cv2.line(frame, (int(i1[0]), int(i1[1])), (int(i2[0]), int(i2[1])), (255, 0, 0), 3)
+
+    r = 9.15
+    pts1, pts2, pts3 = [], [], []
+    base_pos = np.array([11-105/2, 68/2-68/2, 0., 0.])
+    for ang in np.linspace(37, 143, 50):
+        ang = np.deg2rad(ang)
+        pos = base_pos + np.array([r*np.sin(ang), r*np.cos(ang), 0., 1.])
+        ipos = P @ pos
+        ipos /= ipos[-1]
+        pts1.append([ipos[0], ipos[1]])
+
+    base_pos = np.array([94-105/2, 68/2-68/2, 0., 0.])
+    for ang in np.linspace(217, 323, 200):
+        ang = np.deg2rad(ang)
+        pos = base_pos + np.array([r*np.sin(ang), r*np.cos(ang), 0., 1.])
+        ipos = P @ pos
+        ipos /= ipos[-1]
+        pts2.append([ipos[0], ipos[1]])
+
+    base_pos = np.array([0, 0, 0., 0.])
+    for ang in np.linspace(0, 360, 500):
+        ang = np.deg2rad(ang)
+        pos = base_pos + np.array([r*np.sin(ang), r*np.cos(ang), 0., 1.])
+        ipos = P @ pos
+        ipos /= ipos[-1]
+        pts3.append([ipos[0], ipos[1]])
+
+    XEllipse1 = np.array(pts1, np.int32)
+    XEllipse2 = np.array(pts2, np.int32)
+    XEllipse3 = np.array(pts3, np.int32)
+    frame = cv2.polylines(frame, [XEllipse1], False, (255, 0, 0), 3)
+    frame = cv2.polylines(frame, [XEllipse2], False, (255, 0, 0), 3)
+    frame = cv2.polylines(frame, [XEllipse3], False, (255, 0, 0), 3)
+
+    return frame
+
+
+def process_input(input_path, input_type, model_kp, model_line, kp_threshold, line_threshold, pnl_refine,
+                  save_path, display):
+
+    cap = cv2.VideoCapture(input_path)
+    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    fps = int(cap.get(cv2.CAP_PROP_FPS))
+
+    cam = FramebyFrameCalib(iwidth=frame_width, iheight=frame_height, denormalize=True)
+
+    if input_type == 'video':
+        cap = cv2.VideoCapture(input_path)
+        if save_path != "":
+            out = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (frame_width, frame_height))
+
+        pbar = tqdm(total=total_frames)
+
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            final_params_dict = inference(cam, frame, model, model_l, kp_threshold, line_threshold, pnl_refine)
+            if final_params_dict is not None:
+                P = projection_from_cam_params(final_params_dict)
+                projected_frame = project(frame, P)
+            else:
+                projected_frame = frame
+                
+            if save_path != "":
+                out.write(projected_frame)
+    
+            if display:
+                cv2.imshow('Projected Frame', projected_frame)
+                if cv2.waitKey(1) & 0xFF == ord('q'):
+                    break
+            
+            pbar.update(1)
+
+        cap.release()
+        if save_path != "":
+            out.release()
+        cv2.destroyAllWindows()
+
+    elif input_type == 'image':
+        frame = cv2.imread(input_path)
+        if frame is None:
+            print(f"Error: Unable to read the image {input_path}")
+            return
+
+        final_params_dict = inference(cam, frame, model, model_l, kp_threshold, line_threshold, pnl_refine)
+        
+        print("\n"*4,"final_params_dict: ", final_params_dict)
+
+        if final_params_dict is not None:
+            P = projection_from_cam_params(final_params_dict)
+            projected_frame = project(frame, P)
+        else:
+            projected_frame = frame
+
+        if save_path != "":
+            cv2.imwrite(save_path, projected_frame)
+        else:
+            plt.imshow(cv2.cvtColor(projected_frame, cv2.COLOR_BGR2RGB))
+            plt.axis('off')
+            plt.show()
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser(description="Process video or image and plot lines on each frame.")
+    parser.add_argument("--weights_kp", type=str, help="Path to the model for keypoint inference.")
+    parser.add_argument("--weights_line", type=str, help="Path to the model for line projection.")
+    parser.add_argument("--kp_threshold", type=float, default=0.3434, help="Threshold for keypoint detection.")
+    parser.add_argument("--line_threshold", type=float, default=0.7867, help="Threshold for line detection.")
+    parser.add_argument("--pnl_refine", action="store_true", help="Enable PnL refinement module.")
+    parser.add_argument("--device", type=str, default="cuda:0", help="CPU or CUDA device index")
+    parser.add_argument("--input_path", type=str, required=True, help="Path to the input video or image file.")
+    parser.add_argument("--input_type", type=str, choices=['video', 'image'], required=True,
+                        help="Type of input: 'video' or 'image'.")
+    parser.add_argument("--save_path", type=str, default="", help="Path to save the processed video.")
+    parser.add_argument("--display", action="store_true", help="Enable real-time display.")
+    args = parser.parse_args()
+
+
+    input_path = args.input_path
+    input_type = args.input_type
+    model_kp = args.weights_kp
+    model_line = args.weights_line
+    pnl_refine = args.pnl_refine
+    save_path = args.save_path
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    display = args.display and input_type == 'video'
+    kp_threshold = args.kp_threshold
+    line_threshold = args.line_threshold
+
+    cfg = yaml.safe_load(open("config/hrnetv2_w48.yaml", 'r'))
+    cfg_l = yaml.safe_load(open("config/hrnetv2_w48_l.yaml", 'r'))
+
+    loaded_state = torch.load(args.weights_kp, map_location=device, weights_only=True)
+    model = get_cls_net(cfg)
+    model.load_state_dict(loaded_state)
+    model.to(device)
+    model.eval()
+
+    loaded_state_l = torch.load(args.weights_line, map_location=device, weights_only=True)
+    model_l = get_cls_net_l(cfg_l)
+    model_l.load_state_dict(loaded_state_l)
+    model_l.to(device)
+    model_l.eval()
+
+    transform2 = T.Resize((540, 960))
+
+    process_input(input_path, input_type, model_kp, model_line, kp_threshold, line_threshold, pnl_refine,
+                  save_path, display)
+    
+
+    # python inference.py --weights_kp "models/SV_FT_TSWC_kp" --weights_line "models/SV_FT_TSWC_lines" --input_path "examples/input/FootDrone.mp4" --input_type "video" --save_path "examples/output/video.mp4" --kp_threshold 0.15 --line_threshold 0.15 --pnl_refine 
+    # python inference.py --weights_kp "SV_FT_TSWC_kp" --weights_line "SV_FT_TSWC_lines" --input_path "examples/input/FootDrone.jpg" --input_type "image" --save_path "examples/output/FootDrone_inf.jpg" --kp_threshold 0.15 --line_threshold 0.15
+    # python inference.py --weights_kp "models/SV_FT_TSWC_kp" --weights_line "models/SV_FT_TSWC_lines" --input_path "examples/input/fisheye_messi.png" --input_type "image" --save_path "examples/output/fisheye_messi_inf.png" --kp_threshold 0.15 --line_threshold 0.15

model/cls_hrnet.py

@@ -0,0 +1,479 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import logging
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+BatchNorm2d = nn.BatchNorm2d
+BN_MOMENTUM = 0.1
+logger = logging.getLogger(__name__)
+
+
+def conv3x3(in_planes, out_planes, stride=1):
+    """3x3 convolution with padding"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3,
+                     stride=stride, padding=1, bias=False)
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(BasicBlock, self).__init__()
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = BatchNorm2d(planes, momentum=BN_MOMENTUM)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes)
+        self.bn2 = BatchNorm2d(planes, momentum=BN_MOMENTUM)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(Bottleneck, self).__init__()
+        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
+        self.bn1 = BatchNorm2d(planes, momentum=BN_MOMENTUM)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
+                               padding=1, bias=False)
+        self.bn2 = BatchNorm2d(planes, momentum=BN_MOMENTUM)
+        self.conv3 = nn.Conv2d(planes, planes * self.expansion, kernel_size=1,
+                               bias=False)
+        self.bn3 = BatchNorm2d(planes * self.expansion,
+                               momentum=BN_MOMENTUM)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class HighResolutionModule(nn.Module):
+    def __init__(self, num_branches, blocks, num_blocks, num_inchannels,
+                 num_channels, fuse_method, multi_scale_output=True):
+        super(HighResolutionModule, self).__init__()
+        self._check_branches(
+            num_branches, blocks, num_blocks, num_inchannels, num_channels)
+
+        self.num_inchannels = num_inchannels
+        self.fuse_method = fuse_method
+        self.num_branches = num_branches
+
+        self.multi_scale_output = multi_scale_output
+
+        self.branches = self._make_branches(
+            num_branches, blocks, num_blocks, num_channels)
+        self.fuse_layers = self._make_fuse_layers()
+        self.relu = nn.ReLU(inplace=True)
+
+    def _check_branches(self, num_branches, blocks, num_blocks,
+                        num_inchannels, num_channels):
+        if num_branches != len(num_blocks):
+            error_msg = 'NUM_BRANCHES({}) <> NUM_BLOCKS({})'.format(
+                num_branches, len(num_blocks))
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        if num_branches != len(num_channels):
+            error_msg = 'NUM_BRANCHES({}) <> NUM_CHANNELS({})'.format(
+                num_branches, len(num_channels))
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        if num_branches != len(num_inchannels):
+            error_msg = 'NUM_BRANCHES({}) <> NUM_INCHANNELS({})'.format(
+                num_branches, len(num_inchannels))
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+    def _make_one_branch(self, branch_index, block, num_blocks, num_channels,
+                         stride=1):
+        downsample = None
+        if stride != 1 or \
+                self.num_inchannels[branch_index] != num_channels[branch_index] * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(self.num_inchannels[branch_index],
+                          num_channels[branch_index] * block.expansion,
+                          kernel_size=1, stride=stride, bias=False),
+                BatchNorm2d(num_channels[branch_index] * block.expansion,
+                            momentum=BN_MOMENTUM),
+            )
+
+        layers = []
+        layers.append(block(self.num_inchannels[branch_index],
+                            num_channels[branch_index], stride, downsample))
+        self.num_inchannels[branch_index] = \
+            num_channels[branch_index] * block.expansion
+        for i in range(1, num_blocks[branch_index]):
+            layers.append(block(self.num_inchannels[branch_index],
+                                num_channels[branch_index]))
+
+        return nn.Sequential(*layers)
+
+    def _make_branches(self, num_branches, block, num_blocks, num_channels):
+        branches = []
+
+        for i in range(num_branches):
+            branches.append(
+                self._make_one_branch(i, block, num_blocks, num_channels))
+
+        return nn.ModuleList(branches)
+
+    def _make_fuse_layers(self):
+        if self.num_branches == 1:
+            return None
+
+        num_branches = self.num_branches
+        num_inchannels = self.num_inchannels
+        fuse_layers = []
+        for i in range(num_branches if self.multi_scale_output else 1):
+            fuse_layer = []
+            for j in range(num_branches):
+                if j > i:
+                    fuse_layer.append(nn.Sequential(
+                        nn.Conv2d(num_inchannels[j],
+                                  num_inchannels[i],
+                                  1,
+                                  1,
+                                  0,
+                                  bias=False),
+                        BatchNorm2d(num_inchannels[i], momentum=BN_MOMENTUM)))
+                    # nn.Upsample(scale_factor=2**(j-i), mode='nearest')))
+                elif j == i:
+                    fuse_layer.append(None)
+                else:
+                    conv3x3s = []
+                    for k in range(i - j):
+                        if k == i - j - 1:
+                            num_outchannels_conv3x3 = num_inchannels[i]
+                            conv3x3s.append(nn.Sequential(
+                                nn.Conv2d(num_inchannels[j],
+                                          num_outchannels_conv3x3,
+                                          3, 2, 1, bias=False),
+                                BatchNorm2d(num_outchannels_conv3x3, momentum=BN_MOMENTUM)))
+                        else:
+                            num_outchannels_conv3x3 = num_inchannels[j]
+                            conv3x3s.append(nn.Sequential(
+                                nn.Conv2d(num_inchannels[j],
+                                          num_outchannels_conv3x3,
+                                          3, 2, 1, bias=False),
+                                BatchNorm2d(num_outchannels_conv3x3,
+                                            momentum=BN_MOMENTUM),
+                                nn.ReLU(inplace=True)))
+                    fuse_layer.append(nn.Sequential(*conv3x3s))
+            fuse_layers.append(nn.ModuleList(fuse_layer))
+
+        return nn.ModuleList(fuse_layers)
+
+    def get_num_inchannels(self):
+        return self.num_inchannels
+
+    def forward(self, x):
+        if self.num_branches == 1:
+            return [self.branches[0](x[0])]
+
+        for i in range(self.num_branches):
+            x[i] = self.branches[i](x[i])
+
+        x_fuse = []
+        for i in range(len(self.fuse_layers)):
+            y = x[0] if i == 0 else self.fuse_layers[i][0](x[0])
+            for j in range(1, self.num_branches):
+                if i == j:
+                    y = y + x[j]
+                elif j > i:
+                    y = y + F.interpolate(
+                        self.fuse_layers[i][j](x[j]),
+                        size=[x[i].shape[2], x[i].shape[3]],
+                        mode='bilinear')
+                else:
+                    y = y + self.fuse_layers[i][j](x[j])
+            x_fuse.append(self.relu(y))
+
+        return x_fuse
+
+
+blocks_dict = {
+    'BASIC': BasicBlock,
+    'BOTTLENECK': Bottleneck
+}
+
+
+class HighResolutionNet(nn.Module):
+
+    def __init__(self, config, **kwargs):
+        self.inplanes = 64
+        extra = config['MODEL']['EXTRA']
+        super(HighResolutionNet, self).__init__()
+
+        # stem net
+        self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=3, stride=2, padding=1,
+                               bias=False)
+        self.bn1 = BatchNorm2d(self.inplanes, momentum=BN_MOMENTUM)
+        self.conv2 = nn.Conv2d(self.inplanes, self.inplanes, kernel_size=3, stride=2, padding=1,
+                               bias=False)
+        self.bn2 = BatchNorm2d(self.inplanes, momentum=BN_MOMENTUM)
+        self.relu = nn.ReLU(inplace=True)
+        self.sf = nn.Softmax(dim=1)
+        self.layer1 = self._make_layer(Bottleneck, 64, 64, 4)
+
+        self.stage2_cfg = extra['STAGE2']
+        num_channels = self.stage2_cfg['NUM_CHANNELS']
+        block = blocks_dict[self.stage2_cfg['BLOCK']]
+        num_channels = [
+            num_channels[i] * block.expansion for i in range(len(num_channels))]
+        self.transition1 = self._make_transition_layer(
+            [256], num_channels)
+        self.stage2, pre_stage_channels = self._make_stage(
+            self.stage2_cfg, num_channels)
+
+        self.stage3_cfg = extra['STAGE3']
+        num_channels = self.stage3_cfg['NUM_CHANNELS']
+        block = blocks_dict[self.stage3_cfg['BLOCK']]
+        num_channels = [
+            num_channels[i] * block.expansion for i in range(len(num_channels))]
+        self.transition2 = self._make_transition_layer(
+            pre_stage_channels, num_channels)
+        self.stage3, pre_stage_channels = self._make_stage(
+            self.stage3_cfg, num_channels)
+
+        self.stage4_cfg = extra['STAGE4']
+        num_channels = self.stage4_cfg['NUM_CHANNELS']
+        block = blocks_dict[self.stage4_cfg['BLOCK']]
+        num_channels = [
+            num_channels[i] * block.expansion for i in range(len(num_channels))]
+        self.transition3 = self._make_transition_layer(
+            pre_stage_channels, num_channels)
+        self.stage4, pre_stage_channels = self._make_stage(
+            self.stage4_cfg, num_channels, multi_scale_output=True)
+
+        self.upsample = nn.Upsample(scale_factor=2, mode='nearest')
+        final_inp_channels = sum(pre_stage_channels) + self.inplanes
+
+        self.head = nn.Sequential(nn.Sequential(
+            nn.Conv2d(
+                in_channels=final_inp_channels,
+                out_channels=final_inp_channels,
+                kernel_size=1),
+            BatchNorm2d(final_inp_channels, momentum=BN_MOMENTUM),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(
+                in_channels=final_inp_channels,
+                out_channels=config['MODEL']['NUM_JOINTS'],
+                kernel_size=extra['FINAL_CONV_KERNEL']),
+            nn.Softmax(dim=1)))
+
+
+
+    def _make_head(self, x, x_skip):
+        x = self.upsample(x)
+        x = torch.cat([x, x_skip], dim=1)
+        x = self.head(x)
+
+        return x
+
+    def _make_transition_layer(
+            self, num_channels_pre_layer, num_channels_cur_layer):
+        num_branches_cur = len(num_channels_cur_layer)
+        num_branches_pre = len(num_channels_pre_layer)
+
+        transition_layers = []
+        for i in range(num_branches_cur):
+            if i < num_branches_pre:
+                if num_channels_cur_layer[i] != num_channels_pre_layer[i]:
+                    transition_layers.append(nn.Sequential(
+                        nn.Conv2d(num_channels_pre_layer[i],
+                                  num_channels_cur_layer[i],
+                                  3,
+                                  1,
+                                  1,
+                                  bias=False),
+                        BatchNorm2d(
+                            num_channels_cur_layer[i], momentum=BN_MOMENTUM),
+                        nn.ReLU(inplace=True)))
+                else:
+                    transition_layers.append(None)
+            else:
+                conv3x3s = []
+                for j in range(i + 1 - num_branches_pre):
+                    inchannels = num_channels_pre_layer[-1]
+                    outchannels = num_channels_cur_layer[i] \
+                        if j == i - num_branches_pre else inchannels
+                    conv3x3s.append(nn.Sequential(
+                        nn.Conv2d(
+                            inchannels, outchannels, 3, 2, 1, bias=False),
+                        BatchNorm2d(outchannels, momentum=BN_MOMENTUM),
+                        nn.ReLU(inplace=True)))
+                transition_layers.append(nn.Sequential(*conv3x3s))
+
+        return nn.ModuleList(transition_layers)
+
+    def _make_layer(self, block, inplanes, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(inplanes, planes * block.expansion,
+                          kernel_size=1, stride=stride, bias=False),
+                BatchNorm2d(planes * block.expansion, momentum=BN_MOMENTUM),
+            )
+
+        layers = []
+        layers.append(block(inplanes, planes, stride, downsample))
+        inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(block(inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def _make_stage(self, layer_config, num_inchannels,
+                    multi_scale_output=True):
+        num_modules = layer_config['NUM_MODULES']
+        num_branches = layer_config['NUM_BRANCHES']
+        num_blocks = layer_config['NUM_BLOCKS']
+        num_channels = layer_config['NUM_CHANNELS']
+        block = blocks_dict[layer_config['BLOCK']]
+        fuse_method = layer_config['FUSE_METHOD']
+
+        modules = []
+        for i in range(num_modules):
+            # multi_scale_output is only used last module
+            if not multi_scale_output and i == num_modules - 1:
+                reset_multi_scale_output = False
+            else:
+                reset_multi_scale_output = True
+            modules.append(
+                HighResolutionModule(num_branches,
+                                     block,
+                                     num_blocks,
+                                     num_inchannels,
+                                     num_channels,
+                                     fuse_method,
+                                     reset_multi_scale_output)
+            )
+            num_inchannels = modules[-1].get_num_inchannels()
+
+        return nn.Sequential(*modules), num_inchannels
+
+    def forward(self, x):
+        # h, w = x.size(2), x.size(3)
+        x = self.conv1(x)
+        x_skip = x.clone()
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.conv2(x)
+        x = self.bn2(x)
+        x = self.relu(x)
+        x = self.layer1(x)
+
+        x_list = []
+        for i in range(self.stage2_cfg['NUM_BRANCHES']):
+            if self.transition1[i] is not None:
+                x_list.append(self.transition1[i](x))
+            else:
+                x_list.append(x)
+        y_list = self.stage2(x_list)
+
+        x_list = []
+        for i in range(self.stage3_cfg['NUM_BRANCHES']):
+            if self.transition2[i] is not None:
+                x_list.append(self.transition2[i](y_list[-1]))
+            else:
+                x_list.append(y_list[i])
+        y_list = self.stage3(x_list)
+
+        x_list = []
+        for i in range(self.stage4_cfg['NUM_BRANCHES']):
+            if self.transition3[i] is not None:
+                x_list.append(self.transition3[i](y_list[-1]))
+            else:
+                x_list.append(y_list[i])
+        x = self.stage4(x_list)
+
+        # Head Part
+        height, width = x[0].size(2), x[0].size(3)
+        x1 = F.interpolate(x[1], size=(height, width), mode='bilinear', align_corners=False)
+        x2 = F.interpolate(x[2], size=(height, width), mode='bilinear', align_corners=False)
+        x3 = F.interpolate(x[3], size=(height, width), mode='bilinear', align_corners=False)
+        x = torch.cat([x[0], x1, x2, x3], 1)
+        x = self._make_head(x, x_skip)
+
+        return x
+
+    def init_weights(self, pretrained=''):
+        logger.info('=> init weights from normal distribution')
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+                #nn.init.normal_(m.weight, std=0.001)
+                #nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+        if pretrained != '':
+            if os.path.isfile(pretrained):
+                pretrained_dict = torch.load(pretrained)
+                logger.info('=> loading pretrained model {}'.format(pretrained))
+                print('=> loading pretrained model {}'.format(pretrained))
+                model_dict = self.state_dict()
+                pretrained_dict = {k: v for k, v in pretrained_dict.items()
+                                   if k in model_dict.keys()}
+                for k, _ in pretrained_dict.items():
+                    logger.info(
+                        '=> loading {} pretrained model {}'.format(k, pretrained))
+                    #print('=> loading {} pretrained model {}'.format(k, pretrained))
+                model_dict.update(pretrained_dict)
+                self.load_state_dict(model_dict)
+            else:
+                sys.exit(f'Weights {pretrained} not found.')
+
+
+def get_cls_net(config, pretrained='', **kwargs):
+    model = HighResolutionNet(config, **kwargs)
+    model.init_weights(pretrained)
+    return model

model/cls_hrnet_l.py

@@ -0,0 +1,478 @@
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+import os
+import logging
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+BatchNorm2d = nn.BatchNorm2d
+BN_MOMENTUM = 0.1
+logger = logging.getLogger(__name__)
+
+
+def conv3x3(in_planes, out_planes, stride=1):
+    """3x3 convolution with padding"""
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3,
+                     stride=stride, padding=1, bias=False)
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(BasicBlock, self).__init__()
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = BatchNorm2d(planes, momentum=BN_MOMENTUM)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes)
+        self.bn2 = BatchNorm2d(planes, momentum=BN_MOMENTUM)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(Bottleneck, self).__init__()
+        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
+        self.bn1 = BatchNorm2d(planes, momentum=BN_MOMENTUM)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
+                               padding=1, bias=False)
+        self.bn2 = BatchNorm2d(planes, momentum=BN_MOMENTUM)
+        self.conv3 = nn.Conv2d(planes, planes * self.expansion, kernel_size=1,
+                               bias=False)
+        self.bn3 = BatchNorm2d(planes * self.expansion,
+                               momentum=BN_MOMENTUM)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class HighResolutionModule(nn.Module):
+    def __init__(self, num_branches, blocks, num_blocks, num_inchannels,
+                 num_channels, fuse_method, multi_scale_output=True):
+        super(HighResolutionModule, self).__init__()
+        self._check_branches(
+            num_branches, blocks, num_blocks, num_inchannels, num_channels)
+
+        self.num_inchannels = num_inchannels
+        self.fuse_method = fuse_method
+        self.num_branches = num_branches
+
+        self.multi_scale_output = multi_scale_output
+
+        self.branches = self._make_branches(
+            num_branches, blocks, num_blocks, num_channels)
+        self.fuse_layers = self._make_fuse_layers()
+        self.relu = nn.ReLU(inplace=True)
+
+    def _check_branches(self, num_branches, blocks, num_blocks,
+                        num_inchannels, num_channels):
+        if num_branches != len(num_blocks):
+            error_msg = 'NUM_BRANCHES({}) <> NUM_BLOCKS({})'.format(
+                num_branches, len(num_blocks))
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        if num_branches != len(num_channels):
+            error_msg = 'NUM_BRANCHES({}) <> NUM_CHANNELS({})'.format(
+                num_branches, len(num_channels))
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        if num_branches != len(num_inchannels):
+            error_msg = 'NUM_BRANCHES({}) <> NUM_INCHANNELS({})'.format(
+                num_branches, len(num_inchannels))
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+    def _make_one_branch(self, branch_index, block, num_blocks, num_channels,
+                         stride=1):
+        downsample = None
+        if stride != 1 or \
+                self.num_inchannels[branch_index] != num_channels[branch_index] * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(self.num_inchannels[branch_index],
+                          num_channels[branch_index] * block.expansion,
+                          kernel_size=1, stride=stride, bias=False),
+                BatchNorm2d(num_channels[branch_index] * block.expansion,
+                            momentum=BN_MOMENTUM),
+            )
+
+        layers = []
+        layers.append(block(self.num_inchannels[branch_index],
+                            num_channels[branch_index], stride, downsample))
+        self.num_inchannels[branch_index] = \
+            num_channels[branch_index] * block.expansion
+        for i in range(1, num_blocks[branch_index]):
+            layers.append(block(self.num_inchannels[branch_index],
+                                num_channels[branch_index]))
+
+        return nn.Sequential(*layers)
+
+    def _make_branches(self, num_branches, block, num_blocks, num_channels):
+        branches = []
+
+        for i in range(num_branches):
+            branches.append(
+                self._make_one_branch(i, block, num_blocks, num_channels))
+
+        return nn.ModuleList(branches)
+
+    def _make_fuse_layers(self):
+        if self.num_branches == 1:
+            return None
+
+        num_branches = self.num_branches
+        num_inchannels = self.num_inchannels
+        fuse_layers = []
+        for i in range(num_branches if self.multi_scale_output else 1):
+            fuse_layer = []
+            for j in range(num_branches):
+                if j > i:
+                    fuse_layer.append(nn.Sequential(
+                        nn.Conv2d(num_inchannels[j],
+                                  num_inchannels[i],
+                                  1,
+                                  1,
+                                  0,
+                                  bias=False),
+                        BatchNorm2d(num_inchannels[i], momentum=BN_MOMENTUM)))
+                    # nn.Upsample(scale_factor=2**(j-i), mode='nearest')))
+                elif j == i:
+                    fuse_layer.append(None)
+                else:
+                    conv3x3s = []
+                    for k in range(i - j):
+                        if k == i - j - 1:
+                            num_outchannels_conv3x3 = num_inchannels[i]
+                            conv3x3s.append(nn.Sequential(
+                                nn.Conv2d(num_inchannels[j],
+                                          num_outchannels_conv3x3,
+                                          3, 2, 1, bias=False),
+                                BatchNorm2d(num_outchannels_conv3x3, momentum=BN_MOMENTUM)))
+                        else:
+                            num_outchannels_conv3x3 = num_inchannels[j]
+                            conv3x3s.append(nn.Sequential(
+                                nn.Conv2d(num_inchannels[j],
+                                          num_outchannels_conv3x3,
+                                          3, 2, 1, bias=False),
+                                BatchNorm2d(num_outchannels_conv3x3,
+                                            momentum=BN_MOMENTUM),
+                                nn.ReLU(inplace=True)))
+                    fuse_layer.append(nn.Sequential(*conv3x3s))
+            fuse_layers.append(nn.ModuleList(fuse_layer))
+
+        return nn.ModuleList(fuse_layers)
+
+    def get_num_inchannels(self):
+        return self.num_inchannels
+
+    def forward(self, x):
+        if self.num_branches == 1:
+            return [self.branches[0](x[0])]
+
+        for i in range(self.num_branches):
+            x[i] = self.branches[i](x[i])
+
+        x_fuse = []
+        for i in range(len(self.fuse_layers)):
+            y = x[0] if i == 0 else self.fuse_layers[i][0](x[0])
+            for j in range(1, self.num_branches):
+                if i == j:
+                    y = y + x[j]
+                elif j > i:
+                    y = y + F.interpolate(
+                        self.fuse_layers[i][j](x[j]),
+                        size=[x[i].shape[2], x[i].shape[3]],
+                        mode='bilinear')
+                else:
+                    y = y + self.fuse_layers[i][j](x[j])
+            x_fuse.append(self.relu(y))
+
+        return x_fuse
+
+
+blocks_dict = {
+    'BASIC': BasicBlock,
+    'BOTTLENECK': Bottleneck
+}
+
+
+class HighResolutionNet(nn.Module):
+
+    def __init__(self, config, **kwargs):
+        self.inplanes = 64
+        extra = config['MODEL']['EXTRA']
+        super(HighResolutionNet, self).__init__()
+
+        # stem net
+        self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=3, stride=2, padding=1,
+                               bias=False)
+        self.bn1 = BatchNorm2d(self.inplanes, momentum=BN_MOMENTUM)
+        self.conv2 = nn.Conv2d(self.inplanes, self.inplanes, kernel_size=3, stride=2, padding=1,
+                               bias=False)
+        self.bn2 = BatchNorm2d(self.inplanes, momentum=BN_MOMENTUM)
+        self.relu = nn.ReLU(inplace=True)
+        self.sf = nn.Softmax(dim=1)
+        self.layer1 = self._make_layer(Bottleneck, self.inplanes, self.inplanes, 4)
+
+        self.stage2_cfg = extra['STAGE2']
+        num_channels = self.stage2_cfg['NUM_CHANNELS']
+        block = blocks_dict[self.stage2_cfg['BLOCK']]
+        num_channels = [
+            num_channels[i] * block.expansion for i in range(len(num_channels))]
+        self.transition1 = self._make_transition_layer(
+            [256], num_channels)
+        self.stage2, pre_stage_channels = self._make_stage(
+            self.stage2_cfg, num_channels)
+
+        self.stage3_cfg = extra['STAGE3']
+        num_channels = self.stage3_cfg['NUM_CHANNELS']
+        block = blocks_dict[self.stage3_cfg['BLOCK']]
+        num_channels = [
+            num_channels[i] * block.expansion for i in range(len(num_channels))]
+        self.transition2 = self._make_transition_layer(
+            pre_stage_channels, num_channels)
+        self.stage3, pre_stage_channels = self._make_stage(
+            self.stage3_cfg, num_channels)
+
+        self.stage4_cfg = extra['STAGE4']
+        num_channels = self.stage4_cfg['NUM_CHANNELS']
+        block = blocks_dict[self.stage4_cfg['BLOCK']]
+        num_channels = [
+            num_channels[i] * block.expansion for i in range(len(num_channels))]
+        self.transition3 = self._make_transition_layer(
+            pre_stage_channels, num_channels)
+        self.stage4, pre_stage_channels = self._make_stage(
+            self.stage4_cfg, num_channels, multi_scale_output=True)
+
+        self.upsample = nn.Upsample(scale_factor=2, mode='nearest')
+        final_inp_channels = sum(pre_stage_channels) + self.inplanes
+
+        self.head = nn.Sequential(nn.Sequential(
+            nn.Conv2d(
+                in_channels=final_inp_channels,
+                out_channels=final_inp_channels,
+                kernel_size=1),
+            BatchNorm2d(final_inp_channels, momentum=BN_MOMENTUM),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(
+                in_channels=final_inp_channels,
+                out_channels=config['MODEL']['NUM_JOINTS'],
+                kernel_size=extra['FINAL_CONV_KERNEL']),
+            nn.Sigmoid()))
+            
+
+
+
+    def _make_head(self, x, x_skip):
+        x = self.upsample(x)
+        x = torch.cat([x, x_skip], dim=1)
+        x = self.head(x)
+
+        return x
+
+    def _make_transition_layer(
+            self, num_channels_pre_layer, num_channels_cur_layer):
+        num_branches_cur = len(num_channels_cur_layer)
+        num_branches_pre = len(num_channels_pre_layer)
+
+        transition_layers = []
+        for i in range(num_branches_cur):
+            if i < num_branches_pre:
+                if num_channels_cur_layer[i] != num_channels_pre_layer[i]:
+                    transition_layers.append(nn.Sequential(
+                        nn.Conv2d(num_channels_pre_layer[i],
+                                  num_channels_cur_layer[i],
+                                  3,
+                                  1,
+                                  1,
+                                  bias=False),
+                        BatchNorm2d(
+                            num_channels_cur_layer[i], momentum=BN_MOMENTUM),
+                        nn.ReLU(inplace=True)))
+                else:
+                    transition_layers.append(None)
+            else:
+                conv3x3s = []
+                for j in range(i + 1 - num_branches_pre):
+                    inchannels = num_channels_pre_layer[-1]
+                    outchannels = num_channels_cur_layer[i] \
+                        if j == i - num_branches_pre else inchannels
+                    conv3x3s.append(nn.Sequential(
+                        nn.Conv2d(
+                            inchannels, outchannels, 3, 2, 1, bias=False),
+                        BatchNorm2d(outchannels, momentum=BN_MOMENTUM),
+                        nn.ReLU(inplace=True)))
+                transition_layers.append(nn.Sequential(*conv3x3s))
+
+        return nn.ModuleList(transition_layers)
+
+    def _make_layer(self, block, inplanes, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(inplanes, planes * block.expansion,
+                          kernel_size=1, stride=stride, bias=False),
+                BatchNorm2d(planes * block.expansion, momentum=BN_MOMENTUM),
+            )
+
+        layers = []
+        layers.append(block(inplanes, planes, stride, downsample))
+        inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(block(inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def _make_stage(self, layer_config, num_inchannels,
+                    multi_scale_output=True):
+        num_modules = layer_config['NUM_MODULES']
+        num_branches = layer_config['NUM_BRANCHES']
+        num_blocks = layer_config['NUM_BLOCKS']
+        num_channels = layer_config['NUM_CHANNELS']
+        block = blocks_dict[layer_config['BLOCK']]
+        fuse_method = layer_config['FUSE_METHOD']
+
+        modules = []
+        for i in range(num_modules):
+            # multi_scale_output is only used last module
+            if not multi_scale_output and i == num_modules - 1:
+                reset_multi_scale_output = False
+            else:
+                reset_multi_scale_output = True
+            modules.append(
+                HighResolutionModule(num_branches,
+                                     block,
+                                     num_blocks,
+                                     num_inchannels,
+                                     num_channels,
+                                     fuse_method,
+                                     reset_multi_scale_output)
+            )
+            num_inchannels = modules[-1].get_num_inchannels()
+
+        return nn.Sequential(*modules), num_inchannels
+
+    def forward(self, x):
+        # h, w = x.size(2), x.size(3)
+        x = self.conv1(x)
+        x_skip = x.clone()
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.conv2(x)
+        x = self.bn2(x)
+        x = self.relu(x)
+        x = self.layer1(x)
+
+        x_list = []
+        for i in range(self.stage2_cfg['NUM_BRANCHES']):
+            if self.transition1[i] is not None:
+                x_list.append(self.transition1[i](x))
+            else:
+                x_list.append(x)
+        y_list = self.stage2(x_list)
+
+        x_list = []
+        for i in range(self.stage3_cfg['NUM_BRANCHES']):
+            if self.transition2[i] is not None:
+                x_list.append(self.transition2[i](y_list[-1]))
+            else:
+                x_list.append(y_list[i])
+        y_list = self.stage3(x_list)
+
+        x_list = []
+        for i in range(self.stage4_cfg['NUM_BRANCHES']):
+            if self.transition3[i] is not None:
+                x_list.append(self.transition3[i](y_list[-1]))
+            else:
+                x_list.append(y_list[i])
+        x = self.stage4(x_list)
+
+        # Head Part
+        height, width = x[0].size(2), x[0].size(3)
+        x1 = F.interpolate(x[1], size=(height, width), mode='bilinear', align_corners=False)
+        x2 = F.interpolate(x[2], size=(height, width), mode='bilinear', align_corners=False)
+        x3 = F.interpolate(x[3], size=(height, width), mode='bilinear', align_corners=False)
+        x = torch.cat([x[0], x1, x2, x3], 1)
+        x = self._make_head(x, x_skip)
+
+        return x
+
+    def init_weights(self, pretrained=''):
+        logger.info('=> init weights from normal distribution')
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                # nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+                nn.init.normal_(m.weight, std=0.001)
+                # nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+        if os.path.isfile(pretrained):
+            pretrained_dict = torch.load(pretrained)
+            logger.info('=> loading pretrained model {}'.format(pretrained))
+            print('=> loading pretrained model {}'.format(pretrained))
+            model_dict = self.state_dict()
+            pretrained_dict = {k: v for k, v in pretrained_dict.items()
+                               if k in model_dict.keys()}
+            for k, _ in pretrained_dict.items():
+                logger.info(
+                    '=> loading {} pretrained model {}'.format(k, pretrained))
+                #print('=> loading {} pretrained model {}'.format(k, pretrained))
+            model_dict.update(pretrained_dict)
+            self.load_state_dict(model_dict)
+
+
+def get_cls_net(config, pretrained='', **kwargs):
+    model = HighResolutionNet(config, **kwargs)
+    model.init_weights(pretrained)
+    return model
+

model/dataloader.py

@@ -0,0 +1,219 @@
+import copy
+import os
+import sys
+import glob
+import json
+import torch
+import numpy as np
+import torchvision.transforms as T
+import torchvision.transforms.functional as f
+
+from torchvision.transforms import v2
+from torch.utils.data import Dataset
+from PIL import Image
+
+from utils.utils_keypoints import KeypointsDB
+from utils.utils_keypointsWC import KeypointsWCDB
+
+
+class SoccerNetCalibrationDataset(Dataset):
+
+    def __init__(self, root_dir, split, transform, main_cam_only=True):
+
+        self.root_dir = root_dir
+        self.split = split
+        self.transform = transform
+
+        self.match_info = json.load(open(root_dir + split + '/match_info.json'))
+        self.files = self.get_image_files(rate=1)
+
+        if main_cam_only:
+            self.get_main_camera()
+
+    def get_image_files(self, rate=3):
+        files = glob.glob(os.path.join(self.root_dir + self.split, "*.jpg"))
+        files.sort()
+        if rate > 1:
+            files = files[::rate]
+        return files
+
+
+    def __len__(self):
+        return len(self.files)
+
+    def __getitem__(self, idx):
+        if torch.is_tensor(idx):
+            idx = idx.tolist()
+
+        img_name = self.files[idx]
+        image = Image.open(img_name)
+        data = json.load(open(img_name.split('.')[0] + ".json"))
+        data = self.correct_labels(data)
+        sample = self.transform({'image': image, 'data': data})
+
+        img_db = KeypointsDB(sample['data'], sample['image'])
+        target, mask = img_db.get_tensor_w_mask()
+        image = sample['image']
+
+        return image, torch.from_numpy(target).float(), torch.from_numpy(mask).float()
+
+
+    def get_main_camera(self):
+        self.files = [file for file in self.files if int(self.match_info[file.split('/')[-1]]['ms_time']) == \
+                      int(self.match_info[file.split('/')[-1]]['replay_time'])]
+
+    def correct_labels(self, data):
+        if 'Goal left post left' in data.keys():
+            data['Goal left post left '] = copy.deepcopy(data['Goal left post left'])
+            del data['Goal left post left']
+
+        return data
+
+
+class WorldCup2014Dataset(Dataset):
+
+    def __init__(self, root_dir, split, transform):
+        self.root_dir = root_dir
+        self.split = split
+        self.transform = transform
+        assert self.split in ['train_val', 'test'], f'unknown dataset type {self.split}'
+
+        self.files = glob.glob(os.path.join(self.root_dir + self.split, "*.jpg"))
+        self.homographies = glob.glob(os.path.join(self.root_dir + self.split, "*.homographyMatrix"))
+        self.num_samples = len(self.files)
+
+        self.files.sort()
+        self.homographies.sort()
+
+    def __len__(self):
+        return self.num_samples
+
+    def __getitem__(self, idx):
+        image = self.get_image_by_index(idx)
+        homography = self.get_homography_by_index(idx)
+        img_db = KeypointsWCDB(image, homography, (960,540))
+        target, mask = img_db.get_tensor_w_mask()
+
+        sample = self.transform({'image': image, 'target': target, 'mask': mask})
+
+        return sample['image'], sample['target'], sample['mask']
+
+    def convert_homography_WC14GT_to_SN(self, H):
+        T = np.eye(3)
+        #T[0, -1] = -115 / 2
+        #T[1, -1] = -74 / 2
+        yard2meter = 0.9144
+        S = np.eye(3)
+        S[0, 0] = yard2meter
+        S[1, 1] = yard2meter
+        H_SN = S @ (T @ H)
+
+        return H_SN
+
+    def get_image_by_index(self, index):
+        img_file = self.files[index]
+        image = Image.open(img_file)
+        return image
+
+    def get_homography_by_index(self, index):
+        homography_file = self.homographies[index]
+        with open(homography_file, 'r') as file:
+            lines = file.readlines()
+            matrix_elements = []
+            for line in lines:
+                matrix_elements.extend([float(element) for element in line.split()])
+        homography = np.array(matrix_elements).reshape((3, 3))
+        homography = self.convert_homography_WC14GT_to_SN(homography)
+        homography = torch.from_numpy(homography)
+        homography = homography / homography[2:3, 2:3]
+        return homography
+
+
+class TSWorldCupDataset(Dataset):
+
+    def __init__(self, root_dir, split, transform):
+        self.root_dir = root_dir
+        self.split = split
+        self.transform = transform
+        assert self.split in ['train', 'test'], f'unknown dataset type {self.split}'
+
+        self.files_txt = self.get_txt()
+
+        self.files = self.get_jpg_files()
+        self.homographies = self.get_homographies()
+        self.num_samples = len(self.files)
+
+        self.files.sort()
+        self.homographies.sort()
+
+    def __len__(self):
+        return self.num_samples
+
+    def __getitem__(self, idx):
+        image = self.get_image_by_index(idx)
+        homography = self.get_homography_by_index(idx)
+        img_db = KeypointsWCDB(image, homography, (960,540))
+        target, mask = img_db.get_tensor_w_mask()
+
+        sample = self.transform({'image': image, 'target': target, 'mask': mask})
+
+        return sample['image'], sample['target'], sample['mask']
+
+
+    def get_txt(self):
+        with open(self.root_dir + self.split + '.txt', 'r') as file:
+            lines = file.readlines()
+        lines = [line.strip() for line in lines]
+        return lines
+
+    def get_jpg_files(self):
+        all_jpg_files = []
+        for dir in self.files_txt:
+            full_dir = self.root_dir + "Dataset/80_95/" + dir
+            jpg_files = []
+            for file in os.listdir(full_dir):
+                if file.lower().endswith('.jpg') or file.lower().endswith('.jpeg'):
+                    jpg_files.append(os.path.join(full_dir, file))
+
+            all_jpg_files.extend(jpg_files)
+
+        return all_jpg_files
+
+    def get_homographies(self):
+        all_homographies = []
+        for dir in self.files_txt:
+            full_dir = self.root_dir + "Annotations/80_95/" + dir
+            homographies = []
+            for file in os.listdir(full_dir):
+                if file.lower().endswith('.npy'):
+                    homographies.append(os.path.join(full_dir, file))
+
+            all_homographies.extend(homographies)
+
+        return all_homographies
+
+
+    def convert_homography_WC14GT_to_SN(self, H):
+        T = np.eye(3)
+        #T[0, -1] = -115 / 2
+        #T[1, -1] = -74 / 2
+        yard2meter = 0.9144
+        S = np.eye(3)
+        S[0, 0] = yard2meter
+        S[1, 1] = yard2meter
+        H_SN = S @ (T @ H)
+
+        return H_SN
+
+    def get_image_by_index(self, index):
+        img_file = self.files[index]
+        image = Image.open(img_file)
+        return image
+
+    def get_homography_by_index(self, index):
+        homography_file = self.homographies[index]
+        homography = np.load(homography_file)
+        homography = self.convert_homography_WC14GT_to_SN(homography)
+        homography = torch.from_numpy(homography)
+        homography = homography / homography[2:3, 2:3]
+        return homography

model/dataloader_l.py

@@ -0,0 +1,202 @@
+import os
+import sys
+import glob
+import json
+import torch
+import numpy as np
+
+from torchvision.transforms import v2
+from torch.utils.data import Dataset
+from PIL import Image
+
+from utils.utils_lines import LineKeypointsDB
+from utils.utils_linesWC import LineKeypointsWCDB
+
+
+
+class SoccerNetCalibrationDataset(Dataset):
+
+    def __init__(self, root_dir, split, transform, main_cam_only=True):
+
+        self.root_dir = root_dir
+        self.split = split
+        self.transform = transform
+
+        #self.match_info = json.load(open(root_dir + split + '/match_info.json'))
+        self.files = glob.glob(os.path.join(self.root_dir + self.split, "*.jpg"))
+
+        if main_cam_only:
+            self.get_main_camera()
+
+
+    def __len__(self):
+        return len(self.files)
+
+    def __getitem__(self, idx):
+        if torch.is_tensor(idx):
+            idx = idx.tolist()
+
+        img_name = self.files[idx]
+        image = Image.open(img_name)
+        data = json.load(open(img_name.split('.')[0] + ".json"))
+        sample = self.transform({'image': image, 'data': data})
+
+        img_db = LineKeypointsDB(sample['data'], sample['image'])
+        target = img_db.get_tensor()
+
+        return sample['image'], torch.from_numpy(target).float()
+
+    def get_main_camera(self):
+        self.files = [file for file in self.files if int(self.match_info[file.split('/')[-1]]['ms_time']) == \
+                      int(self.match_info[file.split('/')[-1]]['replay_time'])]
+
+
+class WorldCup2014Dataset(Dataset):
+
+    def __init__(self, root_dir, split, transform):
+        self.root_dir = root_dir
+        self.split = split
+        self.transform = transform
+        assert self.split in ['train_val', 'test'], f'unknown dataset type {self.split}'
+
+        self.files = glob.glob(os.path.join(self.root_dir + self.split, "*.jpg"))
+        self.homographies = glob.glob(os.path.join(self.root_dir + self.split, "*.homographyMatrix"))
+        self.num_samples = len(self.files)
+
+        self.files.sort()
+        self.homographies.sort()
+
+    def __len__(self):
+        return self.num_samples
+
+    def __getitem__(self, idx):
+        image = self.get_image_by_index(idx)
+        homography = self.get_homography_by_index(idx)
+        img_db = LineKeypointsWCDB(image, homography, (960,540))
+        target, mask = img_db.get_tensor_w_mask()
+
+        sample = self.transform({'image': image, 'target': target, 'mask': mask})
+
+        return sample['image'], sample['target'], sample['mask']
+
+    def convert_homography_WC14GT_to_SN(self, H):
+        T = np.eye(3)
+        #T[0, -1] = -115 / 2
+        #T[1, -1] = -74 / 2
+        yard2meter = 0.9144
+        S = np.eye(3)
+        S[0, 0] = yard2meter
+        S[1, 1] = yard2meter
+        H_SN = S @ (T @ H)
+
+        return H_SN
+
+    def get_image_by_index(self, index):
+        img_file = self.files[index]
+        image = Image.open(img_file)
+        return image
+
+    def get_homography_by_index(self, index):
+        homography_file = self.homographies[index]
+        with open(homography_file, 'r') as file:
+            lines = file.readlines()
+            matrix_elements = []
+            for line in lines:
+                matrix_elements.extend([float(element) for element in line.split()])
+        homography = np.array(matrix_elements).reshape((3, 3))
+        homography = self.convert_homography_WC14GT_to_SN(homography)
+        homography = torch.from_numpy(homography)
+        homography = homography / homography[2:3, 2:3]
+        return homography
+
+
+
+class TSWorldCupDataset(Dataset):
+
+    def __init__(self, root_dir, split, transform):
+        self.root_dir = root_dir
+        self.split = split
+        self.transform = transform
+        assert self.split in ['train', 'test'], f'unknown dataset type {self.split}'
+
+        self.files_txt = self.get_txt()
+
+        self.files = self.get_jpg_files()
+        self.homographies = self.get_homographies()
+        self.num_samples = len(self.files)
+
+        self.files.sort()
+        self.homographies.sort()
+
+    def __len__(self):
+        return self.num_samples
+
+    def __getitem__(self, idx):
+        image = self.get_image_by_index(idx)
+        homography = self.get_homography_by_index(idx)
+        img_db = LineKeypointsWCDB(image, homography, (960,540))
+        target, mask = img_db.get_tensor_w_mask()
+
+        sample = self.transform({'image': image, 'target': target, 'mask': mask})
+
+        return sample['image'], sample['target'], sample['mask']
+
+
+    def get_txt(self):
+        with open(self.root_dir + self.split + '.txt', 'r') as file:
+            lines = file.readlines()
+        lines = [line.strip() for line in lines]
+        return lines
+
+    def get_jpg_files(self):
+        all_jpg_files = []
+        for dir in self.files_txt:
+            full_dir = self.root_dir + "Dataset/80_95/" + dir
+            jpg_files = []
+            for file in os.listdir(full_dir):
+                if file.lower().endswith('.jpg') or file.lower().endswith('.jpeg'):
+                    jpg_files.append(os.path.join(full_dir, file))
+
+            all_jpg_files.extend(jpg_files)
+
+        return all_jpg_files
+
+    def get_homographies(self):
+        all_homographies = []
+        for dir in self.files_txt:
+            full_dir = self.root_dir + "Annotations/80_95/" + dir
+            homographies = []
+            for file in os.listdir(full_dir):
+                if file.lower().endswith('.npy'):
+                    homographies.append(os.path.join(full_dir, file))
+
+            all_homographies.extend(homographies)
+
+        return all_homographies
+
+
+    def convert_homography_WC14GT_to_SN(self, H):
+        T = np.eye(3)
+        #T[0, -1] = -115 / 2
+        #T[1, -1] = -74 / 2
+        yard2meter = 0.9144
+        S = np.eye(3)
+        S[0, 0] = yard2meter
+        S[1, 1] = yard2meter
+        H_SN = S @ (T @ H)
+
+        return H_SN
+
+    def get_image_by_index(self, index):
+        img_file = self.files[index]
+        image = Image.open(img_file)
+        return image
+
+    def get_homography_by_index(self, index):
+        homography_file = self.homographies[index]
+        homography = np.load(homography_file)
+        homography = self.convert_homography_WC14GT_to_SN(homography)
+        homography = torch.from_numpy(homography)
+        homography = homography / homography[2:3, 2:3]
+        return homography
+

model/losses.py

@@ -0,0 +1,221 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class MSELoss(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.criterion = nn.MSELoss(reduction='none')
+
+    def forward(self, output, target, mask=None):
+        loss = self.criterion(output, target)
+        if mask is not None:
+            loss = (loss * mask).mean()
+        else:
+            loss = (loss).mean()
+        return loss
+
+class KLDivLoss(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.criterion = nn.KLDivLoss(reduction='batchmean')
+
+    def forward(self, output, target, mask=None):
+        if mask is not None:
+            output_masked = output * mask
+            target_masked = target * mask
+            loss = self.criterion(F.log_softmax(output_masked), target_masked)
+        else:
+            loss = self.criterion(F.log_softmax(output), target)
+        return loss
+
+class HeatmapWeightingMSELoss(nn.Module):
+
+    def __init__(self):
+        super().__init__()
+        self.criterion = nn.MSELoss(reduction='none')
+
+    def forward(self, output, target, mask=None):
+        """Forward function."""
+        batch_size = output.size(0)
+        num_joints = output.size(1)
+
+        heatmaps_pred = output.reshape(
+            (batch_size, num_joints, -1)).split(1, 1)
+        heatmaps_gt = target.reshape((batch_size, num_joints, -1)).split(1, 1)
+
+        loss = 0.
+
+        for idx in range(num_joints):
+            heatmap_pred = heatmaps_pred[idx].squeeze(1)
+            heatmap_gt = heatmaps_gt[idx].squeeze(1)
+            """
+            Set different weight generation functions.
+            weight = heatmap_gt + 1
+            weight = heatmap_gt * 2 + 1
+            weight = heatmap_gt * heatmap_gt + 1
+            weight = torch.exp(heatmap_gt + 1)
+            """
+
+            if mask is not None:
+                #weight = heatmap_gt * mask[:, idx] + 1
+                weight = torch.exp(heatmap_gt * mask[:, idx] + 1)
+                loss += torch.mean(self.criterion(heatmap_pred * mask[:, idx],
+                                                    heatmap_gt * mask[:, idx]) * weight)
+            else:
+                weight = heatmap_gt + 1
+                loss += torch.mean(self.criterion(heatmap_pred, heatmap_gt) * weight)
+        return loss / (num_joints+1)
+
+
+class CombMSEAW(nn.Module):
+    def __init__(self, lambda1=1, lambda2=1, alpha=2.1, omega=14, epsilon=1, theta=0.5):
+        super().__init__()
+        # Adaptive wing loss
+        self.lambda1 = lambda1
+        self.lambda2 = lambda2
+        self.criterion1 = nn.MSELoss(reduction='none')
+        self.alpha = alpha
+        self.omega = omega
+        self.epsilon = epsilon
+        self.theta = theta
+
+
+    def forward(self, pred, target, mask=None):
+        loss = 0
+        if mask is not None:
+            pred_masked, target_masked = pred * mask, target * mask
+            loss += self.lambda1 * self.criterion1(pred_masked, target_masked)
+            loss += self.lambda2 * self.adaptive_wing(pred_masked, target_masked)
+        else:
+            loss += self.lambda1 * self.criterion1(pred, target)
+            loss += self.lambda2 * self.adaptive_wing(pred, target)
+        return torch.mean(loss)
+
+    def adaptive_wing(self, pred, target):
+        delta = (target - pred).abs()
+        alpha_t = self.alpha - target
+        A = self.omega * (
+                1 / (1 + torch.pow(self.theta / self.epsilon,
+                                   alpha_t))) * alpha_t \
+            * (torch.pow(self.theta / self.epsilon,
+                         self.alpha - target - 1)) * (1 / self.epsilon)
+        C = self.theta * A - self.omega * torch.log(
+            1 + torch.pow(self.theta / self.epsilon, alpha_t))
+
+        losses = torch.where(delta < self.theta,
+                             self.omega * torch.log(
+                                 1 + torch.pow(delta / self.epsilon, alpha_t)),
+                             A * delta - C)
+        return losses
+
+
+
+class AdaptiveWingLoss(nn.Module):
+    def __init__(self, alpha=2.1, omega=14, epsilon=1, theta=0.5):
+        super().__init__()
+        # Adaptive wing loss
+        self.alpha = alpha
+        self.omega = omega
+        self.epsilon = epsilon
+        self.theta = theta
+
+    def forward(self, pred, target, mask=None):
+        if mask is not None:
+            pred_masked, target_masked = pred * mask, target * mask
+            loss = self.adaptive_wing(pred_masked, target_masked)
+        else:
+            loss = self.adaptive_wing(pred, target)
+        return loss
+
+    def adaptive_wing(self, pred, target):
+        delta = (target - pred).abs()
+        alpha_t = self.alpha - target
+        A = self.omega * (
+                1 / (1 + torch.pow(self.theta / self.epsilon,
+                                   alpha_t))) * alpha_t \
+            * (torch.pow(self.theta / self.epsilon,
+                         self.alpha - target - 1)) * (1 / self.epsilon)
+        C = self.theta * A - self.omega * torch.log(
+            1 + torch.pow(self.theta / self.epsilon, alpha_t))
+
+        losses = torch.where(delta < self.theta,
+                             self.omega * torch.log(
+                                 1 + torch.pow(delta / self.epsilon, alpha_t)),
+                             A * delta - C)
+        return torch.mean(losses)
+
+class GaussianFocalLoss(nn.Module):
+    """GaussianFocalLoss is a variant of focal loss.
+    More details can be found in the `paper
+    <https://arxiv.org/abs/1808.01244>`_
+    Code is modified from `kp_utils.py
+    <https://github.com/princeton-vl/CornerNet/blob/master/models/py_utils/kp_utils.py#L152>`_  # noqa: E501
+    Please notice that the target in GaussianFocalLoss is a gaussian heatmap,
+    not 0/1 binary target.
+    Args:
+        alpha (float): Power of prediction.
+        gamma (float): Power of target for negative samples.
+        reduction (str): Options are "none", "mean" and "sum".
+        loss_weight (float): Loss weight of current loss.
+    """
+
+    def __init__(self,
+                 alpha=2.0,
+                 gamma=4.0,
+                 reduction='mean',
+                 loss_weight=1.0):
+        super(GaussianFocalLoss, self).__init__()
+        self.alpha = alpha
+        self.gamma = gamma
+        self.reduction = reduction
+        self.loss_weight = loss_weight
+
+    def forward(self,
+                pred,
+                target,
+                mask=None,
+                weight=None,
+                avg_factor=None,
+                reduction_override=None):
+        """Forward function.
+        Args:
+            pred (torch.Tensor): The prediction.
+            target (torch.Tensor): The learning target of the prediction
+                in gaussian distribution.
+            weight (torch.Tensor, optional): The weight of loss for each
+                prediction. Defaults to None.
+            avg_factor (int, optional): Average factor that is used to average
+                the loss. Defaults to None.
+            reduction_override (str, optional): The reduction method used to
+                override the original reduction method of the loss.
+                Defaults to None.
+        """
+        assert reduction_override in (None, 'none', 'mean', 'sum')
+        reduction = (reduction_override if reduction_override else self.reduction)
+        if mask is not None:
+            pred_masked, target_masked = pred * mask, target * mask
+            loss_reg = self.loss_weight * self.gaussian_focal_loss(pred_masked, target_masked, alpha=self.alpha,
+                                                                   gamma=self.gamma)
+        else:
+            loss_reg = self.loss_weight * self.gaussian_focal_loss(pred, target, alpha=self.alpha, gamma=self.gamma)
+        return loss_reg.mean()
+
+    def gaussian_focal_loss(self, pred, gaussian_target, alpha=2.0, gamma=4.0):
+        """`Focal Loss <https://arxiv.org/abs/1708.02002>`_ for targets in gaussian
+        distribution.
+        Args:
+            pred (torch.Tensor): The prediction.
+            gaussian_target (torch.Tensor): The learning target of the prediction
+                in gaussian distribution.
+            alpha (float, optional): A balanced form for Focal Loss.
+                Defaults to 2.0.
+            gamma (float, optional): The gamma for calculating the modulating
+                factor. Defaults to 4.0.
+        """
+        eps = 1e-12
+        pos_weights = gaussian_target.eq(1)
+        neg_weights = (1 - gaussian_target).pow(gamma)
+        pos_loss = -(pred + eps).log() * (1 - pred).pow(alpha) * pos_weights
+        neg_loss = -(1 - pred + eps).log() * pred.pow(alpha) * neg_weights
+        return pos_loss + neg_loss

model/metrics.py

@@ -0,0 +1,312 @@
+import cv2
+import torch
+import scipy
+import random
+import numpy as np
+
+from shapely.geometry import Point, Polygon, MultiPoint
+
+def calculate_metrics(gt, pred, mask, conf_th=0.1, dist_th=5):
+    geometry_mask = (mask[:, :-1] > 0).cpu()
+
+    pred_mask = torch.all((pred[:, :, :, -1] > conf_th), dim=-1)
+    gt_mask = torch.all((gt[:, :, :, -1] > conf_th), dim=-1)
+
+    pred_pos = pred[geometry_mask][:, 0, :]
+    pred_mask = pred_mask[geometry_mask]
+    gt_pos = gt[geometry_mask][:, 0, :]
+    gt_mask = gt_mask[geometry_mask]
+
+    distances = torch.norm(pred_pos - gt_pos, dim=1)
+
+    # Count true positives, false positives, and false negatives based on distance threshold
+    true_positives = ((distances < dist_th) & pred_mask & gt_mask).sum().item()
+    true_negatives = (~pred_mask & ~gt_mask).sum().item()
+    false_positives = ((pred_mask & ~gt_mask) | ((distances >= dist_th) & pred_mask & gt_mask)).sum().item()
+    false_negatives = (~pred_mask & gt_mask).sum().item()
+
+    # Calculate precision, recall, and F1 score
+    accuracy = (true_positives + true_negatives) / geometry_mask.sum().item()
+    precision = true_positives / (true_positives + false_positives + 1e-10)
+    recall = true_positives / (true_positives + false_negatives + 1e-10)
+    f1 = 2 * (precision * recall) / (precision + recall + 1e-10)
+
+    return accuracy, precision, recall, f1
+
+
+def calculate_metrics_l(gt, pred, conf_th=0.1, dist_th=5):
+
+    pred_pos = pred[:, :, :, :-1]
+    gt_pos = gt[:, :, :, :-1]
+
+    pred_mask = torch.all((pred[:, :, :, -1] > conf_th), dim=-1)
+    gt_mask = torch.all((gt[:, :, :, -1] > conf_th), dim=-1)
+
+    gt_flip = torch.flip(gt_pos, dims=[2])
+
+    distances1 = torch.norm(pred_pos - gt_pos, dim=-1)
+    distances2 = torch.norm(pred_pos - gt_flip, dim=-1)
+
+    distances1_bool = torch.all((distances1 < dist_th), dim=-1)
+    distances2_bool = torch.all((distances2 < dist_th), dim=-1)
+
+    # Count true positives, false positives, and false negatives based on distance threshold
+    true_positives = ((distances1_bool | distances2_bool) & pred_mask & gt_mask).sum().item()
+    true_negatives = (~pred_mask & ~gt_mask).sum().item()
+    false_positives = (
+            (pred_mask & ~gt_mask) | ((~distances1_bool & ~distances2_bool) & pred_mask & gt_mask)).sum().item()
+    false_negatives = (~pred_mask & gt_mask).sum().item()
+
+    # Calculate precision, recall, and F1 score
+    accuracy = (true_positives + true_negatives) / (gt.size()[1] * gt.size()[0])
+    precision = true_positives / (true_positives + false_positives + 1e-10)
+    recall = true_positives / (true_positives + false_negatives + 1e-10)
+    f1 = 2 * (precision * recall) / (precision + recall + 1e-10)
+
+    return accuracy, precision, recall, f1
+
+
+def calculate_metrics_l_with_mask(gt, pred, mask, conf_th=0.1, dist_th=5):
+
+    #only works with batch 1. Should be adapted to batch > 1 in an organic way or just do a loop over batch
+
+    geometry_mask = (mask[:, :-1] > 0).cpu()
+
+    pred = pred[geometry_mask]
+    gt = gt[geometry_mask]
+
+    pred_pos = pred[:, :, :-1]
+    gt_pos = gt[:, :, :-1]
+
+    pred_mask = torch.all((pred[:, :, -1] > conf_th), dim=-1)
+    gt_mask = torch.all((gt[:, :, -1] > conf_th), dim=-1)
+
+    gt_flip = torch.flip(gt_pos, dims=[1])
+
+    distances1 = torch.norm(pred_pos - gt_pos, dim=-1)
+    distances2 = torch.norm(pred_pos - gt_flip, dim=-1)
+
+    distances1_bool = torch.all((distances1 < dist_th), dim=-1)
+    distances2_bool = torch.all((distances2 < dist_th), dim=-1)
+
+    # Count true positives, false positives, and false negatives based on distance threshold
+    true_positives = ((distances1_bool | distances2_bool) & pred_mask & gt_mask).sum().item()
+    true_negatives = (~pred_mask & ~gt_mask).sum().item()
+    false_positives = (
+            (pred_mask & ~gt_mask) | ((~distances1_bool & ~distances2_bool) & pred_mask & gt_mask)).sum().item()
+    false_negatives = (~pred_mask & gt_mask).sum().item()
+
+    # Calculate precision, recall, and F1 score
+    accuracy = (true_positives + true_negatives) / geometry_mask.sum().item()
+    precision = true_positives / (true_positives + false_positives + 1e-10)
+    recall = true_positives / (true_positives + false_negatives + 1e-10)
+    f1 = 2 * (precision * recall) / (precision + recall + 1e-10)
+
+    return accuracy, precision, recall, f1
+
+
+def calc_iou_whole_with_poly(pred_h, gt_h, frame_w=1280, frame_h=720, template_w=115, template_h=74):
+
+    corners = np.array([[0, 0],
+                        [frame_w - 1, 0],
+                        [frame_w - 1, frame_h - 1],
+                        [0, frame_h - 1]], dtype=np.float64)
+
+    mapping_mat = np.linalg.inv(gt_h)
+    mapping_mat /= mapping_mat[2, 2]
+
+    gt_corners = cv2.perspectiveTransform(
+        corners[:, None, :], gt_h)  # inv_gt_mat * (gt_mat * [x, y, 1])
+    gt_corners = cv2.perspectiveTransform(
+        gt_corners, np.linalg.inv(gt_h))
+    gt_corners = gt_corners[:, 0, :]
+
+    pred_corners = cv2.perspectiveTransform(
+        corners[:, None, :], gt_h)  # inv_pred_mat * (gt_mat * [x, y, 1])
+    pred_corners = cv2.perspectiveTransform(
+        pred_corners, np.linalg.inv(pred_h))
+    pred_corners = pred_corners[:, 0, :]
+
+    gt_poly = Polygon(gt_corners.tolist())
+    pred_poly = Polygon(pred_corners.tolist())
+
+    # f, axarr = plt.subplots(1, 2, figsize=(16, 12))
+    # axarr[0].plot(*gt_poly.exterior.coords.xy)
+    # axarr[1].plot(*pred_poly.exterior.coords.xy)
+    # plt.show()
+
+    if pred_poly.is_valid is False:
+        return 0., None, None
+
+    if not gt_poly.intersects(pred_poly):
+        print('not intersects')
+        iou = 0.
+    else:
+        intersection = gt_poly.intersection(pred_poly).area
+        union = gt_poly.area + pred_poly.area - intersection
+        if union <= 0.:
+            print('whole union', union)
+            iou = 0.
+        else:
+            iou = intersection / union
+
+    return iou, None, None
+
+def calc_iou_part(pred_h, gt_h, frame_w=1280, frame_h=720, template_w=115, template_h=74):
+
+    # field template binary mask
+    field_mask = np.ones((frame_h, frame_w, 3), dtype=np.uint8) * 255
+    gt_mask = cv2.warpPerspective(field_mask, gt_h, (template_w, template_h),
+                                  cv2.INTER_AREA, borderMode=cv2.BORDER_CONSTANT, borderValue=(0))
+
+    pred_mask = cv2.warpPerspective(field_mask, pred_h, (template_w, template_h),
+                                    cv2.INTER_AREA, borderMode=cv2.BORDER_CONSTANT, borderValue=(0))
+
+    gt_mask[gt_mask > 0] = 255
+    pred_mask[pred_mask > 0] = 255
+
+    intersection = ((gt_mask > 0) * (pred_mask > 0)).sum()
+    union = (gt_mask > 0).sum() + (pred_mask > 0).sum() - intersection
+
+    if union <= 0:
+        print('part union', union)
+        # iou = float('nan')
+        iou = 0.
+    else:
+        iou = float(intersection) / float(union)
+
+    # === blending ===
+    gt_white_area = (gt_mask[:, :, 0] == 255) & (
+            gt_mask[:, :, 1] == 255) & (gt_mask[:, :, 2] == 255)
+    gt_fill = gt_mask.copy()
+    gt_fill[gt_white_area, 0] = 255
+    gt_fill[gt_white_area, 1] = 0
+    gt_fill[gt_white_area, 2] = 0
+    pred_white_area = (pred_mask[:, :, 0] == 255) & (
+            pred_mask[:, :, 1] == 255) & (pred_mask[:, :, 2] == 255)
+    pred_fill = pred_mask.copy()
+    pred_fill[pred_white_area, 0] = 0
+    pred_fill[pred_white_area, 1] = 255
+    pred_fill[pred_white_area, 2] = 0
+    gt_maskf = gt_fill.astype(float) / 255
+    pred_maskf = pred_fill.astype(float) / 255
+    fill_resultf = cv2.addWeighted(gt_maskf, 0.5,
+                                   pred_maskf, 0.5, 0.0)
+    fill_result = np.uint8(fill_resultf * 255)
+
+    return iou
+
+def calc_proj_error(pred_h, gt_h, frame_w=1280, frame_h=720, template_w=115, template_h=74):
+
+    field_mask = np.ones((template_h, template_w, 3), dtype=np.uint8) * 255
+    gt_mask = cv2.warpPerspective(field_mask, np.linalg.inv(
+        gt_h), (frame_w, frame_h), borderMode=cv2.BORDER_CONSTANT, borderValue=(0))
+    gt_gray = cv2.cvtColor(gt_mask, cv2.COLOR_BGR2GRAY)
+    contours, hierarchy = cv2.findContours(
+        gt_gray, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+    contour = np.squeeze(contours[0])
+    poly = Polygon(contour)
+    sample_pts = []
+    num_pts = 2500
+    while len(sample_pts) <= num_pts:
+        x = random.sample(range(0, frame_w), 1)
+        y = random.sample(range(0, frame_h), 1)
+        p = Point(x[0], y[0])
+        if p.within(poly):
+            sample_pts.append([x[0], y[0]])
+    sample_pts = np.array(sample_pts, dtype=np.float32)
+
+    field_dim_x, field_dim_y = 100, 60
+    x_scale = field_dim_x / template_w
+    y_scale = field_dim_y / template_h
+    scaling_mat = np.eye(3)
+    scaling_mat[0, 0] = x_scale
+    scaling_mat[1, 1] = y_scale
+    gt_temp_grid = cv2.perspectiveTransform(
+        sample_pts.reshape(-1, 1, 2), scaling_mat @ gt_h)
+    gt_temp_grid = gt_temp_grid.reshape(-1, 2)
+    pred_temp_grid = cv2.perspectiveTransform(
+        sample_pts.reshape(-1, 1, 2), scaling_mat @ pred_h)
+    pred_temp_grid = pred_temp_grid.reshape(-1, 2)
+
+    # TODO compute distance in top view
+    gt_grid_list = []
+    pred_grid_list = []
+    for gt_pts, pred_pts in zip(gt_temp_grid, pred_temp_grid):
+        if 0 <= gt_pts[0] < field_dim_x and 0 <= gt_pts[1] < field_dim_y and \
+                0 <= pred_pts[0] < field_dim_x and 0 <= pred_pts[1] < field_dim_y:
+            gt_grid_list.append(gt_pts)
+            pred_grid_list.append(pred_pts)
+    gt_grid_list = np.array(gt_grid_list)
+    pred_grid_list = np.array(pred_grid_list)
+
+    if gt_grid_list.shape != pred_grid_list.shape:
+        print('proj error:', gt_grid_list.shape, pred_grid_list.shape)
+    assert gt_grid_list.shape == pred_grid_list.shape, 'shape mismatch'
+
+    if gt_grid_list.size != 0 and pred_grid_list.size != 0:
+        distance_list = calc_euclidean_distance(
+            gt_grid_list, pred_grid_list, axis=1)
+        return distance_list.mean()  # average all keypoints
+    else:
+        print(gt_grid_list)
+        print(pred_grid_list)
+        return float('nan')
+
+def calc_euclidean_distance(a, b, _norm=np.linalg.norm, axis=None):
+    return _norm(a - b, axis=axis)
+
+def gen_template_grid():
+    # === set uniform grid ===
+    # field_dim_x, field_dim_y = 105.000552, 68.003928 # in meter
+    field_dim_x, field_dim_y = 114.83, 74.37  # in yard
+    # field_dim_x, field_dim_y = 115, 74 # in yard
+    nx, ny = (13, 7)
+    x = np.linspace(0, field_dim_x, nx)
+    y = np.linspace(0, field_dim_y, ny)
+    xv, yv = np.meshgrid(x, y, indexing='ij')
+    uniform_grid = np.stack((xv, yv), axis=2).reshape(-1, 2)
+    uniform_grid = np.concatenate((uniform_grid, np.ones(
+        (uniform_grid.shape[0], 1))), axis=1)  # top2bottom, left2right
+    # TODO: class label in template, each keypoints is (x, y, c), c is label that starts from 1
+    for idx, pts in enumerate(uniform_grid):
+        pts[2] = idx + 1  # keypoints label
+    return uniform_grid
+
+def calc_reproj_error(pred_h, gt_h, frame_w=1280, frame_h=720, template_w=115, template_h=74):
+
+    uniform_grid = gen_template_grid()  # grid shape (91, 3), (x, y, label)
+    template_grid = uniform_grid[:, :2].copy()
+    template_grid = template_grid.reshape(-1, 1, 2)
+
+    gt_warp_grid = cv2.perspectiveTransform(template_grid, np.linalg.inv(gt_h))
+    gt_warp_grid = gt_warp_grid.reshape(-1, 2)
+    pred_warp_grid = cv2.perspectiveTransform(
+        template_grid, np.linalg.inv(pred_h))
+    pred_warp_grid = pred_warp_grid.reshape(-1, 2)
+
+    # TODO compute distance in camera view
+    gt_grid_list = []
+    pred_grid_list = []
+    for gt_pts, pred_pts in zip(gt_warp_grid, pred_warp_grid):
+        if 0 <= gt_pts[0] < frame_w and 0 <= gt_pts[1] < frame_h and \
+                0 <= pred_pts[0] < frame_w and 0 <= pred_pts[1] < frame_h:
+            gt_grid_list.append(gt_pts)
+            pred_grid_list.append(pred_pts)
+    gt_grid_list = np.array(gt_grid_list)
+    pred_grid_list = np.array(pred_grid_list)
+
+    if gt_grid_list.shape != pred_grid_list.shape:
+        print('reproj error:', gt_grid_list.shape, pred_grid_list.shape)
+    assert gt_grid_list.shape == pred_grid_list.shape, 'shape mismatch'
+
+    if gt_grid_list.size != 0 and pred_grid_list.size != 0:
+        distance_list = calc_euclidean_distance(
+            gt_grid_list, pred_grid_list, axis=1)
+        distance_list /= frame_h  # normalize by image height
+        return distance_list.mean()  # average all keypoints
+    else:
+        print(gt_grid_list)
+        print(pred_grid_list)
+        return float('nan')
+

model/transforms.py

@@ -0,0 +1,364 @@
+import torch
+import math
+import numbers
+import warnings
+import numpy as np
+import torch.nn.functional as F
+import torchvision.transforms.functional as f
+import torchvision.transforms as T
+import torchvision.transforms.v2 as v2
+
+from torchvision.transforms.functional import _interpolation_modes_from_int, InterpolationMode
+from torchvision import transforms as _transforms
+from typing import List, Optional, Tuple, Union
+from scipy import ndimage
+from torch import Tensor
+
+from sn_calibration.src.evaluate_extremities import mirror_labels
+
+
+
+class ToTensor(torch.nn.Module):
+    def __call__(self, sample):
+        image = sample['image']
+
+
+        return {'image': f.to_tensor(image).float(),
+                'data': sample['data']}
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}()"
+
+
+class Normalize(torch.nn.Module):
+    def __init__(self, mean, std):
+        super().__init__()
+        self.mean = mean
+        self.std = std
+
+    def forward(self, sample):
+        image = sample['image']
+        image = f.normalize(image, self.mean, self.std)
+
+        return {'image': image,
+                'data': sample['data']}
+
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(mean={self.mean}, std={self.std})"
+
+
+FLIP_POSTS = {
+    'Goal left post right': 'Goal left post left ',
+    'Goal left post left ': 'Goal left post right',
+    'Goal right post right': 'Goal right post left',
+    'Goal right post left': 'Goal right post right'
+}
+
+h_lines = ['Goal left crossbar', 'Side line left', 'Small rect. left main', 'Big rect. left main', 'Middle line',
+           'Big rect. right main', 'Small rect. right main', 'Side line right', 'Goal right crossbar']
+v_lines = ['Side line top', 'Big rect. left top', 'Small rect. left top', 'Small rect. left bottom',
+           'Big rect. left bottom', 'Big rect. right top', 'Small rect. right top', 'Small rect. right bottom',
+           'Big rect. right bottom', 'Side line bottom']
+
+def swap_top_bottom_names(line_name: str) -> str:
+    x: str = 'top'
+    y: str = 'bottom'
+    if x in line_name or y in line_name:
+        return y.join(part.replace(y, x) for part in line_name.split(x))
+    return line_name
+
+
+def swap_posts_names(line_name: str) -> str:
+    if line_name in FLIP_POSTS:
+        return FLIP_POSTS[line_name]
+    return line_name
+
+
+def flip_annot_names(annot, swap_top_bottom: bool = True,
+                     swap_posts: bool = True):
+    annot = mirror_labels(annot)
+    if swap_top_bottom:
+        annot = {swap_top_bottom_names(k): v for k, v in annot.items()}
+    if swap_posts:
+        annot = {swap_posts_names(k): v for k, v in annot.items()}
+    return annot
+
+
+class RandomHorizontalFlip(torch.nn.Module):
+    def __init__(self, p=0.5):
+        super().__init__()
+        self.p = p
+
+    def forward(self, sample):
+        if torch.rand(1) < self.p:
+            image, data = sample['image'], sample['data']
+            image = f.hflip(image)
+            data = flip_annot_names(data)
+            for line in data:
+                for point in data[line]:
+                    point['x'] = 1.0 - point['x']
+
+            return {'image': image,
+                    'data': data}
+        else:
+            return {'image': sample['image'],
+                    'data': sample['data']}
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(p={self.p})"
+
+
+class LRAmbiguityFix(torch.nn.Module):
+    def __init__(self, v_th, h_th):
+        super().__init__()
+        self.v_th = v_th
+        self.h_th = h_th
+
+    def forward(self, sample):
+        data = sample['data']
+
+        if len(data) == 0:
+            return {'image': sample['image'],
+                    'data': sample['data']}
+
+        n_left, n_right = self.compute_n_sides(data)
+
+        angles_v, angles_h = [], []
+        for line in data.keys():
+            line_points = []
+            for point in data[line]:
+                line_points.append((point['x'], point['y']))
+
+            sorted_points = sorted(line_points, key=lambda point: (point[0], point[1]))
+            pi, pf = sorted_points[0], sorted_points[-1]
+            if line in h_lines:
+                angle_h = self.calculate_angle_h(pi[0], pi[1], pf[0], pf[1])
+                if angle_h:
+                    angles_h.append(abs(angle_h))
+            if line in v_lines:
+                angle_v = self.calculate_angle_v(pi[0], pi[1], pf[0], pf[1])
+                if angle_v:
+                    angles_v.append(abs(angle_v))
+
+
+        if len(angles_h) > 0 and len(angles_v) > 0:
+            if np.mean(angles_h) < self.h_th and np.mean(angles_v) < self.v_th:
+                if n_right > n_left:
+                    data = flip_annot_names(data, swap_top_bottom=False, swap_posts=False)
+
+        return {'image': sample['image'],
+                'data': data}
+
+    def calculate_angle_h(self, x1, y1, x2, y2):
+        if not x2 - x1 == 0:
+            slope = (y2 - y1) / (x2 - x1)
+            angle = math.atan(slope)
+            angle_degrees = math.degrees(angle)
+            return angle_degrees
+        else:
+            return None
+    def calculate_angle_v(self, x1, y1, x2, y2):
+        if not x2 - x1 == 0:
+            slope = (y2 - y1) / (x2 - x1)
+            angle = math.atan(1 / slope) if slope != 0 else math.pi / 2  # Avoid division by zero
+            angle_degrees = math.degrees(angle)
+            return angle_degrees
+        else:
+            return None
+
+    def compute_n_sides(self, data):
+        n_left, n_right = 0, 0
+        for line in data:
+            line_words = line.split()[:3]
+            if 'left' in line_words:
+                n_left += 1
+            elif 'right' in line_words:
+                n_right += 1
+        return n_left, n_right
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(v_th={self.v_th}, h_th={self.h_th})"
+
+
+class AddGaussianNoise(torch.nn.Module):
+    def __init__(self, mean=0., std=2.):
+        self.std = std
+        self.mean = mean
+
+    def __call__(self, sample):
+        image = sample['image']
+        image += torch.randn(image.size()) * self.std + self.mean
+        image = torch.clip(image, 0, 1)
+
+        return {'image': image,
+                'data': sample['data']}
+
+    def __repr__(self):
+        return self.__class__.__name__ + '(mean={0}, std={1})'.format(self.mean, self.std)
+
+
+class ColorJitter(torch.nn.Module):
+
+    def __init__(
+            self,
+            brightness: Union[float, Tuple[float, float]] = 0,
+            contrast: Union[float, Tuple[float, float]] = 0,
+            saturation: Union[float, Tuple[float, float]] = 0,
+            hue: Union[float, Tuple[float, float]] = 0,
+    ) -> None:
+        super().__init__()
+        self.brightness = self._check_input(brightness, "brightness")
+        self.contrast = self._check_input(contrast, "contrast")
+        self.saturation = self._check_input(saturation, "saturation")
+        self.hue = self._check_input(hue, "hue", center=0, bound=(-0.5, 0.5), clip_first_on_zero=False)
+
+    @torch.jit.unused
+    def _check_input(self, value, name, center=1, bound=(0, float("inf")), clip_first_on_zero=True):
+        if isinstance(value, numbers.Number):
+            if value < 0:
+                raise ValueError(f"If {name} is a single number, it must be non negative.")
+            value = [center - float(value), center + float(value)]
+            if clip_first_on_zero:
+                value[0] = max(value[0], 0.0)
+        elif isinstance(value, (tuple, list)) and len(value) == 2:
+            value = [float(value[0]), float(value[1])]
+        else:
+            raise TypeError(f"{name} should be a single number or a list/tuple with length 2.")
+
+        if not bound[0] <= value[0] <= value[1] <= bound[1]:
+            raise ValueError(f"{name} values should be between {bound}, but got {value}.")
+
+        # if value is 0 or (1., 1.) for brightness/contrast/saturation
+        # or (0., 0.) for hue, do nothing
+        if value[0] == value[1] == center:
+            return None
+        else:
+            return tuple(value)
+
+    @staticmethod
+    def get_params(
+            brightness: Optional[List[float]],
+            contrast: Optional[List[float]],
+            saturation: Optional[List[float]],
+            hue: Optional[List[float]],
+    ) -> Tuple[Tensor, Optional[float], Optional[float], Optional[float], Optional[float]]:
+        """Get the parameters for the randomized transform to be applied on image.
+
+        Args:
+            brightness (tuple of float (min, max), optional): The range from which the brightness_factor is chosen
+                uniformly. Pass None to turn off the transformation.
+            contrast (tuple of float (min, max), optional): The range from which the contrast_factor is chosen
+                uniformly. Pass None to turn off the transformation.
+            saturation (tuple of float (min, max), optional): The range from which the saturation_factor is chosen
+                uniformly. Pass None to turn off the transformation.
+            hue (tuple of float (min, max), optional): The range from which the hue_factor is chosen uniformly.
+                Pass None to turn off the transformation.
+
+        Returns:
+            tuple: The parameters used to apply the randomized transform
+            along with their random order.
+        """
+        fn_idx = torch.randperm(4)
+
+        b = None if brightness is None else float(torch.empty(1).uniform_(brightness[0], brightness[1]))
+        c = None if contrast is None else float(torch.empty(1).uniform_(contrast[0], contrast[1]))
+        s = None if saturation is None else float(torch.empty(1).uniform_(saturation[0], saturation[1]))
+        h = None if hue is None else float(torch.empty(1).uniform_(hue[0], hue[1]))
+
+        return fn_idx, b, c, s, h
+
+
+    def forward(self, sample):
+        """
+        Args:
+            img (PIL Image or Tensor): Input image.
+
+        Returns:
+            PIL Image or Tensor: Color jittered image.
+        """
+        fn_idx, brightness_factor, contrast_factor, saturation_factor, hue_factor = self.get_params(
+            self.brightness, self.contrast, self.saturation, self.hue
+        )
+
+        image = sample['image']
+
+        for fn_id in fn_idx:
+            if fn_id == 0 and brightness_factor is not None:
+                image = f.adjust_brightness(image, brightness_factor)
+            elif fn_id == 1 and contrast_factor is not None:
+                image = f.adjust_contrast(image, contrast_factor)
+            elif fn_id == 2 and saturation_factor is not None:
+                image = f.adjust_saturation(image, saturation_factor)
+            elif fn_id == 3 and hue_factor is not None:
+                image = f.adjust_hue(image, hue_factor)
+
+        return {'image': image,
+                'data': sample['data']}
+
+
+    def __repr__(self) -> str:
+        s = (
+            f"{self.__class__.__name__}("
+            f"brightness={self.brightness}"
+            f", contrast={self.contrast}"
+            f", saturation={self.saturation}"
+            f", hue={self.hue})"
+        )
+        return s
+
+
+class Resize(torch.nn.Module):
+    def __init__(self, size, interpolation=InterpolationMode.BILINEAR):
+        super().__init__()
+        self.size = size
+
+        # Backward compatibility with integer value
+        if isinstance(interpolation, int):
+            warnings.warn(
+                "Argument interpolation should be of type InterpolationMode instead of int. "
+                "Please, use InterpolationMode enum."
+            )
+            interpolation = _interpolation_modes_from_int(interpolation)
+
+        self.interpolation = interpolation
+
+    def forward(self, sample):
+        image = sample["image"]
+        image = f.resize(image, self.size, self.interpolation)
+
+        return {'image': image,
+                'data': sample['data']}
+
+
+    def __repr__(self):
+        interpolate_str = self.interpolation.value
+        return self.__class__.__name__ + '(size={0}, interpolation={1})'.format(self.size, interpolate_str)
+
+
+
+transforms = v2.Compose([
+    ToTensor(),
+    RandomHorizontalFlip(p=.5),
+    ColorJitter(brightness=(0.05), contrast=(0.05), saturation=(0.05), hue=(0.05)),
+    AddGaussianNoise(0, .1)
+])
+
+transforms_w_LR = v2.Compose([
+    ToTensor(),
+    RandomHorizontalFlip(p=.5),
+    LRAmbiguityFix(v_th=70, h_th=20),
+    ColorJitter(brightness=(0.05), contrast=(0.05), saturation=(0.05), hue=(0.05)),
+    AddGaussianNoise(0, .1)
+])
+
+no_transforms = v2.Compose([
+    ToTensor()
+])
+
+no_transforms_w_LR = v2.Compose([
+    ToTensor(),
+    LRAmbiguityFix(v_th=70, h_th=20)
+])
+
+

model/transformsWC.py

@@ -0,0 +1,212 @@
+import torch
+import math
+import numbers
+import torch.nn.functional as F
+import torchvision.transforms.functional as f
+import torchvision.transforms as T
+import torchvision.transforms.v2 as v2
+
+from torchvision import transforms as _transforms
+from typing import List, Optional, Tuple, Union
+from scipy import ndimage
+from torch import Tensor
+
+from sn_calibration.src.evaluate_extremities import mirror_labels
+
+class ToTensor(torch.nn.Module):
+    def __call__(self, sample):
+        image, target, mask = sample['image'], sample['target'], sample['mask']
+
+        return {'image': f.to_tensor(image).float(),
+                'target': torch.from_numpy(target).float(),
+                'mask': torch.from_numpy(mask).float()}
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}()"
+
+class RandomHorizontalFlip(torch.nn.Module):
+    def __init__(self, p=0.5):
+        super().__init__()
+        self.p = p
+        self.swap_dict = {1:3, 2:2, 3:1, 4:7, 5:6, 6:5, 7:4, 8:11, 9:10, 10:9, 11:8, 12:15, 13:14, 14:13, 15:12,
+                          16:19, 17:18, 18:17, 19:16, 20:23, 21:22, 22:21, 23:20, 24:27, 25:26, 26:25, 27:24, 28:30,
+                          29:29, 30:28, 31:33, 32:32, 33:31, 34:36, 35:35, 36:34, 37:40, 38:39, 39:38, 40:37, 41:44,
+                          42:43, 43:42, 44:41, 45:57, 46:56, 47:55, 48:49, 49:48, 50:52, 51:51, 52:50, 53:54, 54:53,
+                          55:47, 56:46, 57:45, 58:58}
+
+
+    def forward(self, sample):
+        if torch.rand(1) < self.p:
+            image, target, mask = sample['image'], sample['target'], sample['mask']
+            image = f.hflip(image)
+            target = f.hflip(target)
+
+            target_swap, mask_swap = self.swap_layers(target, mask)
+
+            return {'image': image,
+                    'target': target_swap,
+                    'mask': mask_swap}
+        else:
+            return {'image': sample['image'],
+                    'target': sample['target'],
+                    'mask': sample['mask']}
+
+
+    def swap_layers(self, target, mask):
+        target_swap = torch.zeros_like(target)
+        mask_swap = torch.zeros_like(mask)
+        for kp in self.swap_dict.keys():
+            kp_swap = self.swap_dict[kp]
+            target_swap[kp_swap-1, :, :] = target[kp-1, :, :].clone()
+            mask_swap[kp_swap-1] = mask[kp-1].clone()
+
+        return target_swap, mask_swap
+
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(p={self.p})"
+
+
+class AddGaussianNoise(torch.nn.Module):
+    def __init__(self, mean=0., std=2.):
+        self.std = std
+        self.mean = mean
+
+    def __call__(self, sample):
+        image = sample['image']
+        image += torch.randn(image.size()) * self.std + self.mean
+        image = torch.clip(image, 0, 1)
+
+        return {'image': image,
+                'target': sample['target'],
+                'mask': sample['mask']}
+
+    def __repr__(self):
+        return self.__class__.__name__ + '(mean={0}, std={1})'.format(self.mean, self.std)
+
+
+class ColorJitter(torch.nn.Module):
+
+    def __init__(
+            self,
+            brightness: Union[float, Tuple[float, float]] = 0,
+            contrast: Union[float, Tuple[float, float]] = 0,
+            saturation: Union[float, Tuple[float, float]] = 0,
+            hue: Union[float, Tuple[float, float]] = 0,
+    ) -> None:
+        super().__init__()
+        self.brightness = self._check_input(brightness, "brightness")
+        self.contrast = self._check_input(contrast, "contrast")
+        self.saturation = self._check_input(saturation, "saturation")
+        self.hue = self._check_input(hue, "hue", center=0, bound=(-0.5, 0.5), clip_first_on_zero=False)
+
+    @torch.jit.unused
+    def _check_input(self, value, name, center=1, bound=(0, float("inf")), clip_first_on_zero=True):
+        if isinstance(value, numbers.Number):
+            if value < 0:
+                raise ValueError(f"If {name} is a single number, it must be non negative.")
+            value = [center - float(value), center + float(value)]
+            if clip_first_on_zero:
+                value[0] = max(value[0], 0.0)
+        elif isinstance(value, (tuple, list)) and len(value) == 2:
+            value = [float(value[0]), float(value[1])]
+        else:
+            raise TypeError(f"{name} should be a single number or a list/tuple with length 2.")
+
+        if not bound[0] <= value[0] <= value[1] <= bound[1]:
+            raise ValueError(f"{name} values should be between {bound}, but got {value}.")
+
+        # if value is 0 or (1., 1.) for brightness/contrast/saturation
+        # or (0., 0.) for hue, do nothing
+        if value[0] == value[1] == center:
+            return None
+        else:
+            return tuple(value)
+
+    @staticmethod
+    def get_params(
+            brightness: Optional[List[float]],
+            contrast: Optional[List[float]],
+            saturation: Optional[List[float]],
+            hue: Optional[List[float]],
+    ) -> Tuple[Tensor, Optional[float], Optional[float], Optional[float], Optional[float]]:
+        """Get the parameters for the randomized transform to be applied on image.
+
+        Args:
+            brightness (tuple of float (min, max), optional): The range from which the brightness_factor is chosen
+                uniformly. Pass None to turn off the transformation.
+            contrast (tuple of float (min, max), optional): The range from which the contrast_factor is chosen
+                uniformly. Pass None to turn off the transformation.
+            saturation (tuple of float (min, max), optional): The range from which the saturation_factor is chosen
+                uniformly. Pass None to turn off the transformation.
+            hue (tuple of float (min, max), optional): The range from which the hue_factor is chosen uniformly.
+                Pass None to turn off the transformation.
+
+        Returns:
+            tuple: The parameters used to apply the randomized transform
+            along with their random order.
+        """
+        fn_idx = torch.randperm(4)
+
+        b = None if brightness is None else float(torch.empty(1).uniform_(brightness[0], brightness[1]))
+        c = None if contrast is None else float(torch.empty(1).uniform_(contrast[0], contrast[1]))
+        s = None if saturation is None else float(torch.empty(1).uniform_(saturation[0], saturation[1]))
+        h = None if hue is None else float(torch.empty(1).uniform_(hue[0], hue[1]))
+
+        return fn_idx, b, c, s, h
+
+
+    def forward(self, sample):
+        """
+        Args:
+            img (PIL Image or Tensor): Input image.
+
+        Returns:
+            PIL Image or Tensor: Color jittered image.
+        """
+        fn_idx, brightness_factor, contrast_factor, saturation_factor, hue_factor = self.get_params(
+            self.brightness, self.contrast, self.saturation, self.hue
+        )
+
+        image = sample['image']
+
+        for fn_id in fn_idx:
+            if fn_id == 0 and brightness_factor is not None:
+                image = f.adjust_brightness(image, brightness_factor)
+            elif fn_id == 1 and contrast_factor is not None:
+                image = f.adjust_contrast(image, contrast_factor)
+            elif fn_id == 2 and saturation_factor is not None:
+                image = f.adjust_saturation(image, saturation_factor)
+            elif fn_id == 3 and hue_factor is not None:
+                image = f.adjust_hue(image, hue_factor)
+
+        return {'image': image,
+                'target': sample['target'],
+                'mask': sample['mask']}
+
+
+    def __repr__(self) -> str:
+        s = (
+            f"{self.__class__.__name__}("
+            f"brightness={self.brightness}"
+            f", contrast={self.contrast}"
+            f", saturation={self.saturation}"
+            f", hue={self.hue})"
+        )
+        return s
+
+
+
+transforms = v2.Compose([
+    ToTensor(),
+    RandomHorizontalFlip(p=.5),
+    ColorJitter(brightness=(0.05), contrast=(0.05), saturation=(0.05), hue=(0.05)),
+    AddGaussianNoise(0, .1)
+])
+
+
+no_transforms = v2.Compose([
+    ToTensor(),
+])
+
+

model/transformsWC_l.py

@@ -0,0 +1,208 @@
+import torch
+import math
+import numbers
+import torch.nn.functional as F
+import torchvision.transforms.functional as f
+import torchvision.transforms as T
+import torchvision.transforms.v2 as v2
+
+from torchvision import transforms as _transforms
+from typing import List, Optional, Tuple, Union
+from scipy import ndimage
+from torch import Tensor
+
+from sn_calibration.src.evaluate_extremities import mirror_labels
+
+class ToTensor(torch.nn.Module):
+    def __call__(self, sample):
+        image, target, mask = sample['image'], sample['target'], sample['mask']
+
+        return {'image': f.to_tensor(image).float(),
+                'target': torch.from_numpy(target).float(),
+                'mask': torch.from_numpy(mask).float()}
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}()"
+
+class RandomHorizontalFlip(torch.nn.Module):
+    def __init__(self, p=0.5):
+        super().__init__()
+        self.p = p
+        self.swap_dict = {1: 4, 2: 5, 3: 6, 4: 1, 5: 2, 6: 3, 7: 10, 8: 12, 9: 11, 10: 7, 11: 9, 12: 8, 13: 13,
+                          14: 14, 15: 16, 16: 15, 17: 17, 18: 21, 19: 22, 20: 23, 21: 18, 22: 19, 23: 20, 24:24}
+
+    def forward(self, sample):
+        if torch.rand(1) < self.p:
+            image, target, mask = sample['image'], sample['target'], sample['mask']
+            image = f.hflip(image)
+            target = f.hflip(target)
+
+            target_swap, mask_swap = self.swap_layers(target, mask)
+
+            return {'image': image,
+                    'target': target_swap,
+                    'mask': mask_swap}
+        else:
+            return {'image': sample['image'],
+                    'target': sample['target'],
+                    'mask': sample['mask']}
+
+
+    def swap_layers(self, target, mask):
+        target_swap = torch.zeros_like(target)
+        mask_swap = torch.zeros_like(mask)
+        for kp in self.swap_dict.keys():
+            kp_swap = self.swap_dict[kp]
+            target_swap[kp_swap-1, :, :] = target[kp-1, :, :].clone()
+            mask_swap[kp_swap-1] = mask[kp-1].clone()
+
+        return target_swap, mask_swap
+
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(p={self.p})"
+
+
+class AddGaussianNoise(torch.nn.Module):
+    def __init__(self, mean=0., std=2.):
+        self.std = std
+        self.mean = mean
+
+    def __call__(self, sample):
+        image = sample['image']
+        image += torch.randn(image.size()) * self.std + self.mean
+        image = torch.clip(image, 0, 1)
+
+        return {'image': image,
+                'target': sample['target'],
+                'mask': sample['mask']}
+
+    def __repr__(self):
+        return self.__class__.__name__ + '(mean={0}, std={1})'.format(self.mean, self.std)
+
+
+class ColorJitter(torch.nn.Module):
+
+    def __init__(
+            self,
+            brightness: Union[float, Tuple[float, float]] = 0,
+            contrast: Union[float, Tuple[float, float]] = 0,
+            saturation: Union[float, Tuple[float, float]] = 0,
+            hue: Union[float, Tuple[float, float]] = 0,
+    ) -> None:
+        super().__init__()
+        self.brightness = self._check_input(brightness, "brightness")
+        self.contrast = self._check_input(contrast, "contrast")
+        self.saturation = self._check_input(saturation, "saturation")
+        self.hue = self._check_input(hue, "hue", center=0, bound=(-0.5, 0.5), clip_first_on_zero=False)
+
+    @torch.jit.unused
+    def _check_input(self, value, name, center=1, bound=(0, float("inf")), clip_first_on_zero=True):
+        if isinstance(value, numbers.Number):
+            if value < 0:
+                raise ValueError(f"If {name} is a single number, it must be non negative.")
+            value = [center - float(value), center + float(value)]
+            if clip_first_on_zero:
+                value[0] = max(value[0], 0.0)
+        elif isinstance(value, (tuple, list)) and len(value) == 2:
+            value = [float(value[0]), float(value[1])]
+        else:
+            raise TypeError(f"{name} should be a single number or a list/tuple with length 2.")
+
+        if not bound[0] <= value[0] <= value[1] <= bound[1]:
+            raise ValueError(f"{name} values should be between {bound}, but got {value}.")
+
+        # if value is 0 or (1., 1.) for brightness/contrast/saturation
+        # or (0., 0.) for hue, do nothing
+        if value[0] == value[1] == center:
+            return None
+        else:
+            return tuple(value)
+
+    @staticmethod
+    def get_params(
+            brightness: Optional[List[float]],
+            contrast: Optional[List[float]],
+            saturation: Optional[List[float]],
+            hue: Optional[List[float]],
+    ) -> Tuple[Tensor, Optional[float], Optional[float], Optional[float], Optional[float]]:
+        """Get the parameters for the randomized transform to be applied on image.
+
+        Args:
+            brightness (tuple of float (min, max), optional): The range from which the brightness_factor is chosen
+                uniformly. Pass None to turn off the transformation.
+            contrast (tuple of float (min, max), optional): The range from which the contrast_factor is chosen
+                uniformly. Pass None to turn off the transformation.
+            saturation (tuple of float (min, max), optional): The range from which the saturation_factor is chosen
+                uniformly. Pass None to turn off the transformation.
+            hue (tuple of float (min, max), optional): The range from which the hue_factor is chosen uniformly.
+                Pass None to turn off the transformation.
+
+        Returns:
+            tuple: The parameters used to apply the randomized transform
+            along with their random order.
+        """
+        fn_idx = torch.randperm(4)
+
+        b = None if brightness is None else float(torch.empty(1).uniform_(brightness[0], brightness[1]))
+        c = None if contrast is None else float(torch.empty(1).uniform_(contrast[0], contrast[1]))
+        s = None if saturation is None else float(torch.empty(1).uniform_(saturation[0], saturation[1]))
+        h = None if hue is None else float(torch.empty(1).uniform_(hue[0], hue[1]))
+
+        return fn_idx, b, c, s, h
+
+
+    def forward(self, sample):
+        """
+        Args:
+            img (PIL Image or Tensor): Input image.
+
+        Returns:
+            PIL Image or Tensor: Color jittered image.
+        """
+        fn_idx, brightness_factor, contrast_factor, saturation_factor, hue_factor = self.get_params(
+            self.brightness, self.contrast, self.saturation, self.hue
+        )
+
+        image = sample['image']
+
+        for fn_id in fn_idx:
+            if fn_id == 0 and brightness_factor is not None:
+                image = f.adjust_brightness(image, brightness_factor)
+            elif fn_id == 1 and contrast_factor is not None:
+                image = f.adjust_contrast(image, contrast_factor)
+            elif fn_id == 2 and saturation_factor is not None:
+                image = f.adjust_saturation(image, saturation_factor)
+            elif fn_id == 3 and hue_factor is not None:
+                image = f.adjust_hue(image, hue_factor)
+
+        return {'image': image,
+                'target': sample['target'],
+                'mask': sample['mask']}
+
+
+    def __repr__(self) -> str:
+        s = (
+            f"{self.__class__.__name__}("
+            f"brightness={self.brightness}"
+            f", contrast={self.contrast}"
+            f", saturation={self.saturation}"
+            f", hue={self.hue})"
+        )
+        return s
+
+
+
+transforms = v2.Compose([
+    ToTensor(),
+    RandomHorizontalFlip(p=.5),
+    ColorJitter(brightness=(0.05), contrast=(0.05), saturation=(0.05), hue=(0.05)),
+    AddGaussianNoise(0, .1)
+])
+
+
+no_transforms = v2.Compose([
+    ToTensor(),
+])
+
+

model/transforms_l.py

@@ -0,0 +1,360 @@
+import math
+import torch
+import numbers
+import numpy as np
+import torch.nn.functional as F
+import torchvision.transforms.functional as f
+import torchvision.transforms.v2 as v2
+
+from torchvision.transforms.functional import _interpolation_modes_from_int, InterpolationMode
+from torchvision import transforms as _transforms
+from typing import List, Optional, Tuple, Union
+from scipy import ndimage
+from torch import Tensor
+
+from sn_calibration.src.evaluate_extremities import mirror_labels
+
+
+
+class ToTensor(torch.nn.Module):
+    def __call__(self, sample):
+        image, target = sample['image'], sample['data']
+
+
+        return {'image': f.to_tensor(image).float(),
+                'data': sample['data']}
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}()"
+
+
+class Normalize(torch.nn.Module):
+    def __init__(self, mean, std):
+        super().__init__()
+        self.mean = mean
+        self.std = std
+
+    def forward(self, sample):
+        image = sample['image']
+        image = f.normalize(image, self.mean, self.std)
+
+        return {'image': image,
+                'data': sample['data']}
+
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(mean={self.mean}, std={self.std})"
+
+
+FLIP_POSTS = {
+    'Goal left post right': 'Goal left post left ',
+    'Goal left post left ': 'Goal left post right',
+    'Goal right post right': 'Goal right post left',
+    'Goal right post left': 'Goal right post right'
+}
+
+h_lines = ['Goal left crossbar', 'Side line left', 'Small rect. left main', 'Big rect. left main', 'Middle line',
+                   'Big rect. right main', 'Small rect. right main', 'Side line right', 'Goal right crossbar']
+v_lines = ['Side line top', 'Big rect. left top', 'Small rect. left top', 'Small rect. left bottom',
+                   'Big rect. left bottom', 'Big rect. right top', 'Small rect. right top', 'Small rect. right bottom',
+                              'Big rect. right bottom', 'Side line bottom']
+
+def swap_top_bottom_names(line_name: str) -> str:
+    x: str = 'top'
+    y: str = 'bottom'
+    if x in line_name or y in line_name:
+        return y.join(part.replace(y, x) for part in line_name.split(x))
+    return line_name
+
+
+def swap_posts_names(line_name: str) -> str:
+    if line_name in FLIP_POSTS:
+        return FLIP_POSTS[line_name]
+    return line_name
+
+
+def flip_annot_names(annot, swap_top_bottom: bool = True, swap_posts: bool = True):
+    annot = mirror_labels(annot)
+    if swap_top_bottom:
+        annot = {swap_top_bottom_names(k): v for k, v in annot.items()}
+    if swap_posts:
+        annot = {swap_posts_names(k): v for k, v in annot.items()}
+    return annot
+
+
+class LRAmbiguityFix(torch.nn.Module):
+    def __init__(self, v_th, h_th):
+        super().__init__()
+        self.v_th = v_th
+        self.h_th = h_th
+
+    def forward(self, sample):
+        data = sample['data']
+
+        if len(data) == 0:
+            return {'image': sample['image'],
+                    'data': sample['data']}
+
+        n_left, n_right = self.compute_n_sides(data)
+
+        angles_v, angles_h = [], []
+        for line in data.keys():
+            line_points = []
+            for point in data[line]:
+                line_points.append((point['x'], point['y']))
+
+            sorted_points = sorted(line_points, key=lambda point: (point[0], point[1]))
+            pi, pf = sorted_points[0], sorted_points[-1]
+            if line in h_lines:
+                angle_h = self.calculate_angle_h(pi[0], pi[1], pf[0], pf[1])
+                if angle_h:
+                    angles_h.append(abs(angle_h))
+            if line in v_lines:
+                angle_v = self.calculate_angle_v(pi[0], pi[1], pf[0], pf[1])
+                if angle_v:
+                    angles_v.append(abs(angle_v))
+
+
+        if len(angles_h) > 0 and len(angles_v) > 0:
+            if np.mean(angles_h) < self.h_th and np.mean(angles_v) < self.v_th:
+                if n_right > n_left:
+                    data = flip_annot_names(data, swap_top_bottom=False, swap_posts=False)
+
+        return {'image': sample['image'],
+                'data': data}
+
+    def calculate_angle_h(self, x1, y1, x2, y2):
+        if not x2 - x1 == 0:
+            slope = (y2 - y1) / (x2 - x1)
+            angle = math.atan(slope)
+            angle_degrees = math.degrees(angle)
+            return angle_degrees
+        else:
+            return None
+    def calculate_angle_v(self, x1, y1, x2, y2):
+        if not x2 - x1 == 0:
+            slope = (y2 - y1) / (x2 - x1)
+            angle = math.atan(1 / slope) if slope != 0 else math.pi / 2  # Avoid division by zero
+            angle_degrees = math.degrees(angle)
+            return angle_degrees
+        else:
+            return None
+
+    def compute_n_sides(self, data):
+        n_left, n_right = 0, 0
+        for line in data:
+            line_words = line.split()[:3]
+            if 'left' in line_words:
+                n_left += 1
+            elif 'right' in line_words:
+                n_right += 1
+        return n_left, n_right
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(v_th={self.v_th}, h_th={self.h_th})"
+
+
+class RandomHorizontalFlip(torch.nn.Module):
+    def __init__(self, p=0.5):
+        super().__init__()
+        self.p = p
+
+    def forward(self, sample):
+        if torch.rand(1) < self.p:
+            image, data = sample['image'], sample['data']
+            image = f.hflip(image)
+            data = flip_annot_names(data)
+            for line in data:
+                for point in data[line]:
+                    point['x'] = 1.0 - point['x']
+
+            return {'image': image,
+                    'data': data}
+        else:
+            return {'image': sample['image'],
+                    'data': sample['data']}
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(p={self.p})"
+
+
+class AddGaussianNoise(torch.nn.Module):
+    def __init__(self, mean=0., std=2.):
+        self.std = std
+        self.mean = mean
+
+    def __call__(self, sample):
+        image = sample['image']
+        image += torch.randn(image.size()) * self.std + self.mean
+        image = torch.clip(image, 0, 1)
+
+        return {'image': image,
+                'data': sample['data']}
+
+    def __repr__(self):
+        return self.__class__.__name__ + '(mean={0}, std={1})'.format(self.mean, self.std)
+
+
+class ColorJitter(torch.nn.Module):
+
+    def __init__(
+            self,
+            brightness: Union[float, Tuple[float, float]] = 0,
+            contrast: Union[float, Tuple[float, float]] = 0,
+            saturation: Union[float, Tuple[float, float]] = 0,
+            hue: Union[float, Tuple[float, float]] = 0,
+    ) -> None:
+        super().__init__()
+        self.brightness = self._check_input(brightness, "brightness")
+        self.contrast = self._check_input(contrast, "contrast")
+        self.saturation = self._check_input(saturation, "saturation")
+        self.hue = self._check_input(hue, "hue", center=0, bound=(-0.5, 0.5), clip_first_on_zero=False)
+
+    @torch.jit.unused
+    def _check_input(self, value, name, center=1, bound=(0, float("inf")), clip_first_on_zero=True):
+        if isinstance(value, numbers.Number):
+            if value < 0:
+                raise ValueError(f"If {name} is a single number, it must be non negative.")
+            value = [center - float(value), center + float(value)]
+            if clip_first_on_zero:
+                value[0] = max(value[0], 0.0)
+        elif isinstance(value, (tuple, list)) and len(value) == 2:
+            value = [float(value[0]), float(value[1])]
+        else:
+            raise TypeError(f"{name} should be a single number or a list/tuple with length 2.")
+
+        if not bound[0] <= value[0] <= value[1] <= bound[1]:
+            raise ValueError(f"{name} values should be between {bound}, but got {value}.")
+
+        # if value is 0 or (1., 1.) for brightness/contrast/saturation
+        # or (0., 0.) for hue, do nothing
+        if value[0] == value[1] == center:
+            return None
+        else:
+            return tuple(value)
+
+    @staticmethod
+    def get_params(
+            brightness: Optional[List[float]],
+            contrast: Optional[List[float]],
+            saturation: Optional[List[float]],
+            hue: Optional[List[float]],
+    ) -> Tuple[Tensor, Optional[float], Optional[float], Optional[float], Optional[float]]:
+        """Get the parameters for the randomized transform to be applied on image.
+
+        Args:
+            brightness (tuple of float (min, max), optional): The range from which the brightness_factor is chosen
+                uniformly. Pass None to turn off the transformation.
+            contrast (tuple of float (min, max), optional): The range from which the contrast_factor is chosen
+                uniformly. Pass None to turn off the transformation.
+            saturation (tuple of float (min, max), optional): The range from which the saturation_factor is chosen
+                uniformly. Pass None to turn off the transformation.
+            hue (tuple of float (min, max), optional): The range from which the hue_factor is chosen uniformly.
+                Pass None to turn off the transformation.
+
+        Returns:
+            tuple: The parameters used to apply the randomized transform
+            along with their random order.
+        """
+        fn_idx = torch.randperm(4)
+
+        b = None if brightness is None else float(torch.empty(1).uniform_(brightness[0], brightness[1]))
+        c = None if contrast is None else float(torch.empty(1).uniform_(contrast[0], contrast[1]))
+        s = None if saturation is None else float(torch.empty(1).uniform_(saturation[0], saturation[1]))
+        h = None if hue is None else float(torch.empty(1).uniform_(hue[0], hue[1]))
+
+        return fn_idx, b, c, s, h
+
+
+    def forward(self, sample):
+        """
+        Args:
+            img (PIL Image or Tensor): Input image.
+
+        Returns:
+            PIL Image or Tensor: Color jittered image.
+        """
+        fn_idx, brightness_factor, contrast_factor, saturation_factor, hue_factor = self.get_params(
+            self.brightness, self.contrast, self.saturation, self.hue
+        )
+
+        image = sample['image']
+
+        for fn_id in fn_idx:
+            if fn_id == 0 and brightness_factor is not None:
+                image = f.adjust_brightness(image, brightness_factor)
+            elif fn_id == 1 and contrast_factor is not None:
+                image = f.adjust_contrast(image, contrast_factor)
+            elif fn_id == 2 and saturation_factor is not None:
+                image = f.adjust_saturation(image, saturation_factor)
+            elif fn_id == 3 and hue_factor is not None:
+                image = f.adjust_hue(image, hue_factor)
+
+        return {'image': image,
+                'data': sample['data']}
+
+
+    def __repr__(self) -> str:
+        s = (
+            f"{self.__class__.__name__}("
+            f"brightness={self.brightness}"
+            f", contrast={self.contrast}"
+            f", saturation={self.saturation}"
+            f", hue={self.hue})"
+        )
+        return s
+
+
+class Resize(torch.nn.Module):
+    def __init__(self, size, interpolation=InterpolationMode.BILINEAR):
+        super().__init__()
+        self.size = size
+
+        # Backward compatibility with integer value
+        if isinstance(interpolation, int):
+            warnings.warn(
+                "Argument interpolation should be of type InterpolationMode instead of int. "
+                "Please, use InterpolationMode enum."
+            )
+            interpolation = _interpolation_modes_from_int(interpolation)
+
+        self.interpolation = interpolation
+
+    def forward(self, sample):
+        image = sample["image"]
+        image = f.resize(image, self.size, self.interpolation)
+
+        return {'image': image,
+                'data': sample['data']}
+
+
+    def __repr__(self):
+        interpolate_str = self.interpolation.value
+        return self.__class__.__name__ + '(size={0}, interpolation={1})'.format(self.size, interpolate_str)
+
+
+
+
+transforms = v2.Compose([
+    ToTensor(),
+    RandomHorizontalFlip(p=.5),
+    ColorJitter(brightness=(0.05), contrast=(0.05), saturation=(0.05), hue=(0.05)),
+    AddGaussianNoise(0, .1)
+])
+
+transforms_w_LR = v2.Compose([
+    ToTensor(),
+    RandomHorizontalFlip(p=.5),
+    LRAmbiguityFix(v_th=70, h_th=20),
+    ColorJitter(brightness=(0.05), contrast=(0.05), saturation=(0.05), hue=(0.05)),
+    AddGaussianNoise(0, .1)
+])
+
+no_transforms = v2.Compose([
+    ToTensor(),
+])
+
+no_transforms_w_LR = v2.Compose([
+    ToTensor(),
+    LRAmbiguityFix(v_th=70, h_th=20)
+])

requirements.txt

@@ -0,0 +1,44 @@
+# # API Framework
+# fastapi==0.104.1
+# uvicorn[standard]==0.24.0
+# python-multipart==0.0.6
+# pydantic==2.5.0
+
+# # Core dependencies (compatibles Python 3.10)
+# numpy==1.24.3
+# opencv-python-headless==4.8.1.78
+# pillow==10.1.0
+# scipy==1.11.4
+# PyYAML==6.0.1
+# lsq-ellipse==2.2.1
+# shapely==2.0.2
+
+# # PyTorch CPU (compatible Python 3.10)
+# torch==2.1.0
+# torchvision==0.16.0
+
+# # Utilities
+# tqdm==4.66.1
+
+# requirements_clean.txt
+fastapi
+uvicorn[standard]
+python-multipart
+pydantic
+
+# Core dependencies
+numpy
+opencv-python-headless
+pillow
+scipy
+PyYAML
+lsq-ellipse
+shapely
+
+# PyTorch CPU uniquement (beaucoup plus léger)
+--extra-index-url https://download.pytorch.org/whl/cpu
+torch+cpu
+torchvision+cpu
+
+# Utilities
+tqdm

run_api.py

@@ -0,0 +1,13 @@
+import uvicorn
+
+if __name__ == "__main__":
+    print("🚀 Démarrage de l'API Football Vision Calibration...")
+    print("📍 API accessible sur: http://localhost:8000")
+    print("📖 Documentation: http://localhost:8000/docs")
+    
+    uvicorn.run(
+        "api:app",  # ← Changement ici : string au lieu d'objet
+        host="0.0.0.0", 
+        port=8000,
+        reload=True  # Rechargement automatique en développement
+    )

scripts/eval_tswc.py

@@ -0,0 +1,175 @@
+import os
+import sys
+import json
+import glob
+import torch
+import zipfile
+import argparse
+import numpy as np
+
+from tqdm import tqdm
+
+sys.path.insert(1, os.path.join(sys.path[0], '..'))
+from utils.utils_calib import FramebyFrameCalib
+from model.metrics import calc_iou_part, calc_iou_whole_with_poly, calc_reproj_error, calc_proj_error
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--root_dir", type=str, required=True)
+    parser.add_argument("--split", type=str, required=True)
+    parser.add_argument("--pred_file", type=str, required=True)
+
+    args = parser.parse_args()
+    return args
+
+
+def get_homographies(file_paths):
+    npy_files = []
+    for file_path in file_paths:
+        directory_path = os.path.join(os.path.join(args.root_dir, "Annotations/80_95"), file_path)
+        if os.path.exists(directory_path):
+            files = os.listdir(directory_path)
+            npy_files.extend([os.path.join(directory_path, file) for file in files if file.endswith('.npy')])
+
+    npy_files = sorted(npy_files)
+    return npy_files
+
+
+def make_file_name(file):
+    file =  "TS-WorldCup/" + file.split("TS-WorldCup/")[-1]
+    splits = file.split('/')
+    side = splits[3]
+    match = splits[4]
+    image = splits[5]
+    frame = image.split('_homography.npy')[0]
+    return side + '-' + match + '-' + frame + '.json'
+
+
+def pan_tilt_roll_to_orientation(pan, tilt, roll):
+    """
+    Conversion from euler angles to orientation matrix.
+    :param pan:
+    :param tilt:
+    :param roll:
+    :return: orientation matrix
+    """
+    Rpan = np.array([
+        [np.cos(pan), -np.sin(pan), 0],
+        [np.sin(pan), np.cos(pan), 0],
+        [0, 0, 1]])
+    Rroll = np.array([
+        [np.cos(roll), -np.sin(roll), 0],
+        [np.sin(roll), np.cos(roll), 0],
+        [0, 0, 1]])
+    Rtilt = np.array([
+        [1, 0, 0],
+        [0, np.cos(tilt), -np.sin(tilt)],
+        [0, np.sin(tilt), np.cos(tilt)]])
+    rotMat = np.dot(Rpan, np.dot(Rtilt, Rroll))
+    return rotMat
+
+def get_sn_homography(cam_params: dict, batch_size=1):
+    # Extract relevant camera parameters from the dictionary
+    pan_degrees = cam_params['cam_params']['pan_degrees']
+    tilt_degrees = cam_params['cam_params']['tilt_degrees']
+    roll_degrees = cam_params['cam_params']['roll_degrees']
+    x_focal_length = cam_params['cam_params']['x_focal_length']
+    y_focal_length = cam_params['cam_params']['y_focal_length']
+    principal_point = np.array(cam_params['cam_params']['principal_point'])
+    position_meters = np.array(cam_params['cam_params']['position_meters'])
+
+    pan = pan_degrees * np.pi / 180.
+    tilt = tilt_degrees * np.pi / 180.
+    roll = roll_degrees * np.pi / 180.
+
+    rotation = np.array([[-np.sin(pan) * np.sin(roll) * np.cos(tilt) + np.cos(pan) * np.cos(roll),
+                          np.sin(pan) * np.cos(roll) + np.sin(roll) * np.cos(pan) * np.cos(tilt), np.sin(roll) * np.sin(tilt)],
+                         [-np.sin(pan) * np.cos(roll) * np.cos(tilt) - np.sin(roll) * np.cos(pan),
+                          -np.sin(pan) * np.sin(roll) + np.cos(pan) * np.cos(roll) * np.cos(tilt), np.sin(tilt) * np.cos(roll)],
+                         [np.sin(pan) * np.sin(tilt), -np.sin(tilt) * np.cos(pan), np.cos(tilt)]], dtype='float')
+
+    rotation = np.transpose(pan_tilt_roll_to_orientation(pan, tilt, roll))
+
+def convert_homography_SN_to_WC14(H):
+    T = np.eye(3)
+    T[0, -1] = 105 / 2
+    T[1, -1] = 68 / 2
+    meter2yard = 1.09361
+    S = np.eye(3)
+    S[0, 0] = meter2yard
+    S[1, 1] = meter2yard
+    H_SN = S @ (T @ H)
+    return H_SN
+
+def get_homography_by_index(homography_file):
+    homography = np.load(homography_file)
+    homography = homography / homography[2:3, 2:3]
+    return homography
+
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    missed = 0
+    iou_part_list, iou_whole_list = [], []
+    rep_err_list, proj_err_list = [], []
+
+    with open(args.root_dir + args.split + '.txt', 'r') as file:
+        # Read lines from the file and remove trailing newline characters
+        seqs = [line.strip() for line in file.readlines()]
+
+    homographies = get_homographies(seqs)
+    prediction_archive = zipfile.ZipFile(args.pred_file, 'r')
+    cam = FramebyFrameCalib(1280, 720, denormalize=True)
+
+    for h_gt in tqdm(homographies):
+        file_name = h_gt.split('/')[-1].split('.')[0]
+        pred_name = make_file_name(h_gt)
+
+        if pred_name not in prediction_archive.namelist():
+            missed += 1
+            continue
+
+        homography_gt = get_homography_by_index(h_gt)
+        final_dict = prediction_archive.read(pred_name)
+        final_dict = json.loads(final_dict.decode('utf-8'))
+        keypoints_dict = final_dict['kp']
+        lines_dict = final_dict['lines']
+        keypoints_dict = {int(key): value for key, value in keypoints_dict.items()}
+        lines_dict = {int(key): value for key, value in lines_dict.items()}
+
+        cam.update(keypoints_dict, lines_dict)
+        final_dict = cam.heuristic_voting_ground(refine_lines=True)
+        #homography_pred, ret = cam.get_homography_from_ground_plane(use_ransac=20, inverse=True, refine_lines=True)
+        if final_dict is None:
+        #if homography_pred is None:
+            missed += 1
+            continue
+        homography_pred = final_dict["homography"]
+        homography_pred = convert_homography_SN_to_WC14(homography_pred)
+
+        iou_p = calc_iou_part(homography_pred, homography_gt)
+        iou_w, _, _ = calc_iou_whole_with_poly(homography_pred, homography_gt)
+        rep_err = calc_reproj_error(homography_pred, homography_gt)
+        proj_err = calc_proj_error(homography_pred, homography_gt)
+
+        iou_part_list.append(iou_p)
+        iou_whole_list.append(iou_w)
+        rep_err_list.append(rep_err)
+        proj_err_list.append(proj_err)
+
+
+    print(f'Completeness: {1-missed/len(homographies)}')
+    print('IOU Part')
+    print(f'mean: {np.mean(iou_part_list)} \t median: {np.median(iou_part_list)}')
+    print('\nIOU Whole')
+    print(f'mean: {np.mean(iou_whole_list)} \t median: {np.median(iou_whole_list)}')
+    print('\nReprojection Err.')
+    print(f'mean: {np.mean(rep_err_list)} \t median: {np.median(rep_err_list)}')
+    print('\nProjection Err. (meters)')
+    print(f'mean: {np.mean(proj_err_list) * 0.9144} \t median: {np.median(proj_err_list) * 0.9144}')
+
+
+
+
+

scripts/eval_wc14.py

@@ -0,0 +1,154 @@
+import os
+import sys
+import json
+import glob
+
+import torch
+import zipfile
+import argparse
+import numpy as np
+
+from tqdm import tqdm
+from typing import final
+
+sys.path.insert(1, os.path.join(sys.path[0], '..'))
+from utils.utils_calib import FramebyFrameCalib
+from model.metrics import calc_iou_part, calc_iou_whole_with_poly, calc_reproj_error, calc_proj_error
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--root_dir", type=str, required=True)
+    parser.add_argument("--split", type=str, required=True)
+    parser.add_argument("--pred_file", type=str, required=True)
+
+    args = parser.parse_args()
+    return args
+
+
+def pan_tilt_roll_to_orientation(pan, tilt, roll):
+    """
+    Conversion from euler angles to orientation matrix.
+    :param pan:
+    :param tilt:
+    :param roll:
+    :return: orientation matrix
+    """
+    Rpan = np.array([
+        [np.cos(pan), -np.sin(pan), 0],
+        [np.sin(pan), np.cos(pan), 0],
+        [0, 0, 1]])
+    Rroll = np.array([
+        [np.cos(roll), -np.sin(roll), 0],
+        [np.sin(roll), np.cos(roll), 0],
+        [0, 0, 1]])
+    Rtilt = np.array([
+        [1, 0, 0],
+        [0, np.cos(tilt), -np.sin(tilt)],
+        [0, np.sin(tilt), np.cos(tilt)]])
+    rotMat = np.dot(Rpan, np.dot(Rtilt, Rroll))
+    return rotMat
+
+def get_sn_homography(cam_params: dict, batch_size=1):
+    # Extract relevant camera parameters from the dictionary
+    pan_degrees = cam_params['cam_params']['pan_degrees']
+    tilt_degrees = cam_params['cam_params']['tilt_degrees']
+    roll_degrees = cam_params['cam_params']['roll_degrees']
+    x_focal_length = cam_params['cam_params']['x_focal_length']
+    y_focal_length = cam_params['cam_params']['y_focal_length']
+    principal_point = np.array(cam_params['cam_params']['principal_point'])
+    position_meters = np.array(cam_params['cam_params']['position_meters'])
+
+    pan = pan_degrees * np.pi / 180.
+    tilt = tilt_degrees * np.pi / 180.
+    roll = roll_degrees * np.pi / 180.
+
+    rotation = np.array([[-np.sin(pan) * np.sin(roll) * np.cos(tilt) + np.cos(pan) * np.cos(roll),
+                          np.sin(pan) * np.cos(roll) + np.sin(roll) * np.cos(pan) * np.cos(tilt), np.sin(roll) * np.sin(tilt)],
+                         [-np.sin(pan) * np.cos(roll) * np.cos(tilt) - np.sin(roll) * np.cos(pan),
+                          -np.sin(pan) * np.sin(roll) + np.cos(pan) * np.cos(roll) * np.cos(tilt), np.sin(tilt) * np.cos(roll)],
+                         [np.sin(pan) * np.sin(tilt), -np.sin(tilt) * np.cos(pan), np.cos(tilt)]], dtype='float')
+
+    rotation = np.transpose(pan_tilt_roll_to_orientation(pan, tilt, roll))
+
+def convert_homography_SN_to_WC14(H):
+    T = np.eye(3)
+    T[0, -1] = 105 / 2
+    T[1, -1] = 68 / 2
+    meter2yard = 1.09361
+    S = np.eye(3)
+    S[0, 0] = meter2yard
+    S[1, 1] = meter2yard
+    H_SN = S @ (T @ H)
+    return H_SN
+
+def get_homography_by_index(homography_file):
+    with open(homography_file, 'r') as file:
+        lines = file.readlines()
+        matrix_elements = []
+        for line in lines:
+            matrix_elements.extend([float(element) for element in line.split()])
+    homography = np.array(matrix_elements).reshape((3, 3))
+    homography = homography / homography[2:3, 2:3]
+    return homography
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    missed = 0
+    iou_part_list, iou_whole_list = [], []
+    rep_err_list, proj_err_list = [], []
+
+    homographies = glob.glob(os.path.join(args.root_dir + args.split, "*.homographyMatrix"))
+    prediction_archive = zipfile.ZipFile(args.pred_file, 'r')
+    cam = FramebyFrameCalib(1280, 720, denormalize=True)
+
+    for h_gt in tqdm(homographies):
+        file_name = h_gt.split('/')[-1].split('.')[0]
+        pred_name = file_name + '.json'
+
+        if pred_name not in prediction_archive.namelist():
+            missed += 1
+            continue
+
+        homography_gt = get_homography_by_index(h_gt)
+        final_dict = prediction_archive.read(pred_name)
+        final_dict = json.loads(final_dict.decode('utf-8'))
+        keypoints_dict = final_dict['kp']
+        lines_dict = final_dict['lines']
+        keypoints_dict = {int(key): value for key, value in keypoints_dict.items()}
+        lines_dict = {int(key): value for key, value in lines_dict.items()}
+
+        cam.update(keypoints_dict, lines_dict)
+        final_dict = cam.heuristic_voting_ground(refine_lines=True)
+
+        if final_dict is None:
+            missed += 1
+            continue
+
+        homography_pred = final_dict["homography"]
+        homography_pred = convert_homography_SN_to_WC14(homography_pred)
+
+        iou_p = calc_iou_part(homography_pred, homography_gt)
+        iou_w, _, _ = calc_iou_whole_with_poly(homography_pred, homography_gt)
+        rep_err = calc_reproj_error(homography_pred, homography_gt)
+        proj_err = calc_proj_error(homography_pred, homography_gt)
+
+        iou_part_list.append(iou_p)
+        iou_whole_list.append(iou_w)
+        rep_err_list.append(rep_err)
+        proj_err_list.append(proj_err)
+
+
+    print(f'Completeness: {1-missed/len(homographies)}')
+    print('IOU Part')
+    print(f'mean: {np.mean(iou_part_list)} \t median: {np.median(iou_part_list)}')
+    print('\nIOU Whole')
+    print(f'mean: {np.mean(iou_whole_list)} \t median: {np.median(iou_whole_list)}')
+    print('\nReprojection Err.')
+    print(f'mean: {np.mean(rep_err_list)} \t median: {np.median(rep_err_list)}')
+    print('\nProjection Err. (meters)')
+    print(f'mean: {np.mean(proj_err_list) * 0.9144} \t median: {np.median(proj_err_list) * 0.9144}')
+
+
+
+

scripts/inference_sn.py

@@ -0,0 +1,186 @@
+import os
+import sys
+import json
+import glob
+import yaml
+import torch
+import zipfile
+import argparse
+import warnings
+import numpy as np
+import torchvision.transforms as T
+import torchvision.transforms.functional as f
+
+from tqdm import tqdm
+from PIL import Image
+
+sys.path.insert(1, os.path.join(sys.path[0], '..'))
+
+from model.cls_hrnet import get_cls_net
+from model.cls_hrnet_l import get_cls_net as get_cls_net_l
+from utils.utils_keypoints import KeypointsDB
+from utils.utils_lines import LineKeypointsDB
+from utils.utils_heatmap import get_keypoints_from_heatmap_batch_maxpool, get_keypoints_from_heatmap_batch_maxpool_l, \
+    coords_to_dict, complete_keypoints
+from utils.utils_calib import FramebyFrameCalib
+
+warnings.filterwarnings("ignore", category=RuntimeWarning)
+warnings.filterwarnings("ignore", category=np.RankWarning)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--cfg", type=str, required=True,
+                        help="Path to the (kp model) configuration file")
+    parser.add_argument("--cfg_l", type=str, required=True,
+                        help="Path to the (line model) configuration file")
+    parser.add_argument("--root_dir", type=str, required=True,
+                        help="Root directory")
+    parser.add_argument("--split", type=str, required=True,
+                        help="Dataset split")
+    parser.add_argument("--save_dir", type=str, required=True,
+                        help="Saving file path")
+    parser.add_argument("--weights_kp", type=str, required=True,
+                        help="Model (keypoints) weigths to use")
+    parser.add_argument("--weights_line", type=str, required=True,
+                        help="Model (lines) weigths to use")
+    parser.add_argument("--cuda", type=str, default="cuda:0",
+                        help="CUDA device index (default: 'cuda:0')")
+    parser.add_argument("--kp_th", type=float, default="0.1")
+    parser.add_argument("--line_th", type=float, default="0.1")
+    parser.add_argument("--max_reproj_err", type=float, default="50")
+    parser.add_argument("--main_cam_only", action='store_true')
+    parser.add_argument('--use_gt', action='store_true', help='Use ground truth annotations (default: False)')
+
+    args = parser.parse_args()
+    return args
+
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    files = glob.glob(os.path.join(args.root_dir + args.split, "*.jpg"))
+
+    if args.main_cam_only:
+        cam_info = json.load(open(args.root_dir + args.split + '/match_info_cam_gt.json'))
+        files = [file for file in files if file.split('/')[-1] in cam_info.keys()]
+        files = [file for file in files if cam_info[file.split('/')[-1]]['camera'] == 'Main camera center']
+        # files = [file for file in files if int(match_info[file.split('/')[-1]]['ms_time']) == \
+        #                                             int(match_info[file.split('/')[-1]]['replay_time'])]
+
+    if args.main_cam_only:
+        zip_name = args.save_dir + args.split + '_main.zip'
+    else:
+        zip_name = args.save_dir + args.split + '.zip'
+
+    if args.use_gt:
+        if args.main_cam_only:
+            zip_name_pred = args.save_dir + args.split + '_main_gt.zip'
+        else:
+            zip_name_pred = args.save_dir + args.split + '_gt.zip'
+    else:
+        if args.main_cam_only:
+            zip_name_pred = args.save_dir + args.split + '_main_pred.zip'
+        else:
+            zip_name_pred = args.save_dir + args.split + '_pred.zip'
+
+    print(f"Saving results in {args.save_dir}")
+    print(f"file: {zip_name_pred}")
+
+    if args.use_gt:
+        transform = T.Resize((540, 960))
+        cam = FramebyFrameCalib(960, 540, denormalize=True)
+
+        with zipfile.ZipFile(zip_name_pred, 'w') as zip_file:
+            samples, complete = 0., 0.
+            for file in tqdm(files, desc="Processing Images"):
+                image = Image.open(file)
+                file_name = file.split('/')[-1].split('.')[0]
+                samples += 1
+
+                json_path = file.split('.')[0] + ".json"
+                f = open(json_path)
+                data = json.load(f)
+
+                kp_db = KeypointsDB(data, image)
+                line_db = LineKeypointsDB(data, image)
+                heatmaps, _ = kp_db.get_tensor_w_mask()
+                heatmaps = torch.tensor(heatmaps).unsqueeze(0)
+                heatmaps_l = line_db.get_tensor()
+                heatmaps_l = torch.tensor(heatmaps_l).unsqueeze(0)
+                kp_coords = get_keypoints_from_heatmap_batch_maxpool(heatmaps[:, :-1, :, :])
+                line_coords = get_keypoints_from_heatmap_batch_maxpool_l(heatmaps_l[:, :-1, :, :])
+                kp_dict = coords_to_dict(kp_coords, threshold=0.01)
+                lines_dict = coords_to_dict(line_coords, threshold=0.01)
+
+                cam.update(kp_dict, lines_dict)
+                final_params_dict = cam.heuristic_voting()
+                # final_params_dict = cam.calibrate(5)
+
+                if final_params_dict:
+                    complete += 1
+                    cam_params = final_params_dict['cam_params']
+                    print("heheheheheheh")
+                    json_data = json.dumps(cam_params)
+                    zip_file.writestr(f"camera_{file_name}.json", json_data)
+
+    else:
+        device = torch.device(args.cuda if torch.cuda.is_available() else 'cpu')
+        cfg = yaml.safe_load(open(args.cfg, 'r'))
+        cfg_l = yaml.safe_load(open(args.cfg_l, 'r'))
+
+        loaded_state = torch.load(args.weights_kp, map_location=device)
+        model = get_cls_net(cfg)
+        model.load_state_dict(loaded_state)
+        model.to(device)
+        model.eval()
+
+        loaded_state_l = torch.load(args.weights_line, map_location=device)
+        model_l = get_cls_net_l(cfg_l)
+        model_l.load_state_dict(loaded_state_l)
+        model_l.to(device)
+        model_l.eval()
+
+        transform = T.Resize((540, 960))
+        cam = FramebyFrameCalib(960, 540)
+
+        with zipfile.ZipFile(zip_name_pred, 'w') as zip_file:
+            samples, complete = 0., 0.
+            for file in tqdm(files, desc="Processing Images"):
+                image = Image.open(file)
+                file_name = file.split('/')[-1].split('.')[0]
+                samples += 1
+
+                with torch.no_grad():
+                    image = f.to_tensor(image).float().to(device).unsqueeze(0)
+                    image = image if image.size()[-1] == 960 else transform(image)
+                    b, c, h, w = image.size()
+                    heatmaps = model(image)
+                    heatmaps_l = model_l(image)
+
+                    kp_coords = get_keypoints_from_heatmap_batch_maxpool(heatmaps[:, :-1, :, :])
+                    line_coords = get_keypoints_from_heatmap_batch_maxpool_l(heatmaps_l[:, :-1, :, :])
+                    kp_dict = coords_to_dict(kp_coords, threshold=args.kp_th)
+                    lines_dict = coords_to_dict(line_coords, threshold=args.line_th)
+                    kp_dict, lines_dict = complete_keypoints(kp_dict[0], lines_dict[0], w=w, h=h)
+
+                    cam.update(kp_dict, lines_dict)
+                    final_params_dict = cam.heuristic_voting(refine_lines=True)
+
+                if final_params_dict:
+                    if final_params_dict['rep_err'] <= args.max_reproj_err:
+                        complete += 1
+                        cam_params = final_params_dict['cam_params']
+                        json_data = json.dumps(cam_params)
+                        zip_file.writestr(f"camera_{file_name}.json", json_data)
+
+    with zipfile.ZipFile(zip_name, 'w') as zip_file:
+        for file in tqdm(files, desc="Processing Images"):
+            file_name = file.split('/')[-1].split('.')[0]
+            data = json.load(open(file.split('.')[0] + ".json"))
+            json_data = json.dumps(data)
+            zip_file.writestr(f"{file_name}.json", json_data)
+
+    print(f'Completed {complete} / {samples}')
+
+

scripts/inference_tswc.py

@@ -0,0 +1,145 @@
+import os
+import sys
+import json
+import glob
+import yaml
+import torch
+import zipfile
+import argparse
+import warnings
+import numpy as np
+import torchvision.transforms as T
+import torchvision.transforms.functional as f
+
+from tqdm import tqdm
+from PIL import Image
+
+sys.path.insert(1, os.path.join(sys.path[0], '..'))
+from model.cls_hrnet import get_cls_net
+from model.cls_hrnet_l import get_cls_net as get_cls_net_l
+from utils.utils_heatmap import get_keypoints_from_heatmap_batch_maxpool, get_keypoints_from_heatmap_batch_maxpool_l, \
+    complete_keypoints, coords_to_dict
+from utils.utils_keypoints import KeypointsDB
+from utils.utils_lines import LineKeypointsDB
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--cfg", type=str, required=True,
+                        help="Path to the (kp model) configuration file")
+    parser.add_argument("--cfg_l", type=str, required=True,
+                        help="Path to the (line model) configuration file")
+    parser.add_argument("--root_dir", type=str, required=True,
+                        help="Root directory")
+    parser.add_argument("--split", type=str, required=True,
+                        help="Dataset split")
+    parser.add_argument("--save_dir", type=str, required=True,
+                        help="Root directory")
+    parser.add_argument("--weights_kp", type=str, required=True,
+                        help="Model (keypoints) weigths to use")
+    parser.add_argument("--weights_line", type=str, required=True,
+                        help="Model (lines) weigths to use")
+    parser.add_argument("--cuda", type=str, default="cuda:0",
+                        help="CUDA device index (default: 'cuda:0')")
+    parser.add_argument("--kp_th", type=float, default="0.1")
+    parser.add_argument("--line_th", type=float, default="0.1")
+    parser.add_argument("--batch", type=int, default=1, help="Batch size")
+    parser.add_argument("--num_workers", type=int, default=4, help="Number of workers")
+
+
+    args = parser.parse_args()
+    return args
+
+
+def get_files(file_paths):
+    jpg_files = []
+    for file_path in file_paths:
+        directory_path = os.path.join(os.path.join(args.root_dir, "Dataset/80_95"), file_path)
+        if os.path.exists(directory_path):
+            files = os.listdir(directory_path)
+            jpg_files.extend([os.path.join(directory_path, file) for file in files if file.endswith('.jpg')])
+
+    jpg_files = sorted(jpg_files)
+    return jpg_files
+
+def get_homographies(file_paths):
+    npy_files = []
+    for file_path in file_paths:
+        directory_path = os.path.join(os.path.join(args.root_dir, "Annotations/80_95"), file_path)
+        if os.path.exists(directory_path):
+            files = os.listdir(directory_path)
+            npy_files.extend([os.path.join(directory_path, file) for file in files if file.endswith('.npy')])
+
+    npy_files = sorted(npy_files)
+    return npy_files
+
+
+def make_file_name(file):
+    file =  "TS-WorldCup/" + file.split("TS-WorldCup/")[-1]
+    splits = file.split('/')
+    side = splits[3]
+    match = splits[4]
+    image = splits[5]
+    frame = 'IMG_' + image.split('.')[0].split('_')[-1]
+    return side + '-' + match + '-' + frame
+
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    with open(args.root_dir + args.split + '.txt', 'r') as file:
+        # Read lines from the file and remove trailing newline characters
+        seqs = [line.strip() for line in file.readlines()]
+
+    files = get_files(seqs)
+    homographies = get_homographies(seqs)
+
+    zip_name_pred = args.save_dir + args.split + '_pred.zip'
+
+    device = torch.device(args.cuda if torch.cuda.is_available() else 'cpu')
+    cfg = yaml.safe_load(open(args.cfg, 'r'))
+    cfg_l = yaml.safe_load(open(args.cfg_l, 'r'))
+
+    loaded_state = torch.load(args.weights_kp, map_location=device)
+    model = get_cls_net(cfg)
+    model.load_state_dict(loaded_state)
+    model.to(device)
+    model.eval()
+
+    loaded_state_l = torch.load(args.weights_line, map_location=device)
+    model_l = get_cls_net_l(cfg_l)
+    model_l.load_state_dict(loaded_state_l)
+    model_l.to(device)
+    model_l.eval()
+
+    transform = T.Resize((540, 960))
+
+    with zipfile.ZipFile(zip_name_pred, 'w') as zip_file:
+        for count in tqdm(range(len(files)), desc="Processing Images"):
+            image = Image.open(files[count])
+            image = f.to_tensor(image).float().to(device).unsqueeze(0)
+            image = image if image.size()[-1] == 960 else transform(image)
+            b, c, h, w = image.size()
+
+
+            with torch.no_grad():
+                heatmaps = model(image)
+                heatmaps_l = model_l(image)
+
+                kp_coords = get_keypoints_from_heatmap_batch_maxpool(heatmaps[:,:-1,:,:])
+                line_coords = get_keypoints_from_heatmap_batch_maxpool_l(heatmaps_l[:,:-1,:,:])
+                kp_dict = coords_to_dict(kp_coords, threshold=args.kp_th, ground_plane_only=True)
+                lines_dict = coords_to_dict(line_coords, threshold=args.line_th, ground_plane_only=True)
+                final_kp_dict, final_lines_dict = complete_keypoints(kp_dict[0], lines_dict[0],
+                                                                     w=w, h=h, normalize=True)
+                final_dict = {'kp': final_kp_dict, 'lines': final_lines_dict}
+
+                json_data = json.dumps(final_dict)
+                zip_file.writestr(f"{make_file_name(files[count])}.json", json_data)
+
+
+
+
+
+
+

scripts/inference_wc14.py

@@ -0,0 +1,148 @@
+import os
+import sys
+import json
+import glob
+from typing import final
+
+import yaml
+import torch
+import zipfile
+import argparse
+import warnings
+import numpy as np
+import torchvision.transforms as T
+import torchvision.transforms.functional as f
+
+from tqdm import tqdm
+from PIL import Image
+
+sys.path.insert(1, os.path.join(sys.path[0], '..'))
+from model.cls_hrnet import get_cls_net
+from model.cls_hrnet_l import get_cls_net as get_cls_net_l
+from utils.utils_heatmap import get_keypoints_from_heatmap_batch_maxpool, get_keypoints_from_heatmap_batch_maxpool_l, \
+    complete_keypoints, coords_to_dict
+from utils.utils_keypoints import KeypointsDB
+from utils.utils_lines import LineKeypointsDB
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--cfg", type=str, required=True,
+                        help="Path to the (kp model) configuration file")
+    parser.add_argument("--cfg_l", type=str, required=True,
+                        help="Path to the (line model) configuration file")
+    parser.add_argument("--root_dir", type=str, required=True,
+                        help="Root directory")
+    parser.add_argument("--split", type=str, required=True,
+                        help="Dataset split")
+    parser.add_argument("--save_dir", type=str, required=True,
+                        help="Root directory")
+    parser.add_argument("--weights_kp", type=str, required=True,
+                        help="Model (keypoints) weigths to use")
+    parser.add_argument("--weights_line", type=str, required=True,
+                        help="Model (lines) weigths to use")
+    parser.add_argument("--cuda", type=str, default="cuda:0",
+                        help="CUDA device index (default: 'cuda:0')")
+    parser.add_argument("--kp_th", type=float, default="0.1")
+    parser.add_argument("--line_th", type=float, default="0.1")
+    parser.add_argument("--batch", type=int, default=1, help="Batch size")
+    parser.add_argument("--num_workers", type=int, default=4, help="Number of workers")
+    parser.add_argument('--use_gt', action='store_true', help='Use ground truth (default: False)')
+
+
+    args = parser.parse_args()
+    return args
+
+
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    files = glob.glob(os.path.join(args.root_dir + args.split, "*.jpg"))
+
+    if args.use_gt:
+        zip_name_pred = args.save_dir + args.split + '_gt.zip'
+    else:
+        zip_name_pred = args.save_dir + args.split + '_pred.zip'
+
+
+    if args.use_gt:
+        device = torch.device(args.cuda if torch.cuda.is_available() else 'cpu')
+
+        with zipfile.ZipFile(zip_name_pred, 'w') as zip_file:
+            for file in tqdm(files, desc="Processing Images"):
+                image = Image.open(file)
+                w, h = image.size
+
+                homography_file = args.root_dir + args.split + '/' + \
+                                  file.split('/')[-1].split('.')[0] + '.homographyMatrix'
+
+                json_path = file.split('.')[0] + ".json"
+                f = open(json_path)
+                data = json.load(f)
+                kp_db = KeypointsDB(data, image)
+                line_db = LineKeypointsDB(data, image)
+                heatmaps, _ = kp_db.get_tensor_w_mask()
+                heatmaps = torch.tensor(heatmaps).unsqueeze(0)
+                heatmaps_l = line_db.get_tensor()
+                heatmaps_l = torch.tensor(heatmaps_l).unsqueeze(0)
+                kp_coords = get_keypoints_from_heatmap_batch_maxpool(heatmaps[:,:-1,:,:])
+                line_coords = get_keypoints_from_heatmap_batch_maxpool_l(heatmaps_l[:,:-1,:,:])
+                kp_dict = coords_to_dict(kp_coords, threshold=0.1)
+                lines_dict = coords_to_dict(line_coords, threshold=0.1)
+                final_kp_dict = complete_keypoints(kp_dict, lines_dict, w=w, h=h, normalize=True)
+                final_dict = {'kp': final_kp_dict, 'lines': lines_dict}
+
+                json_data = json.dumps(final_dict)
+                zip_file.writestr(f"{file.split('/')[-1].split('.')[0]}.json", json_data)
+
+
+    else:
+        device = torch.device(args.cuda if torch.cuda.is_available() else 'cpu')
+        cfg = yaml.safe_load(open(args.cfg, 'r'))
+        cfg_l = yaml.safe_load(open(args.cfg_l, 'r'))
+
+        loaded_state = torch.load(args.weights_kp, map_location=device)
+        model = get_cls_net(cfg)
+        model.load_state_dict(loaded_state)
+        model.to(device)
+        model.eval()
+
+        loaded_state_l = torch.load(args.weights_line, map_location=device)
+        model_l = get_cls_net_l(cfg_l)
+        model_l.load_state_dict(loaded_state_l)
+        model_l.to(device)
+        model_l.eval()
+
+        transform = T.Resize((540, 960))
+
+        with zipfile.ZipFile(zip_name_pred, 'w') as zip_file:
+            for file in tqdm(files, desc="Processing Images"):
+                image = Image.open(file)
+                image = f.to_tensor(image).float().to(device).unsqueeze(0)
+                image = image if image.size()[-1] == 960 else transform(image)
+                b, c, h, w = image.size()
+
+                homography_file = args.root_dir + args.split + '/' + \
+                                  file.split('/')[-1].split('.')[0] + '.homographyMatrix'
+
+                with torch.no_grad():
+                    heatmaps = model(image)
+                    heatmaps_l = model_l(image)
+
+                    kp_coords = get_keypoints_from_heatmap_batch_maxpool(heatmaps[:,:-1,:,:])
+                    line_coords = get_keypoints_from_heatmap_batch_maxpool_l(heatmaps_l[:,:-1,:,:])
+                    kp_dict = coords_to_dict(kp_coords, threshold=args.kp_th, ground_plane_only=True)
+                    lines_dict = coords_to_dict(line_coords, threshold=args.line_th, ground_plane_only=True)
+                    final_kp_dict, final_lines_dict = complete_keypoints(kp_dict[0], lines_dict[0],
+                                                                        w=w, h=h, normalize=True)
+                    final_dict = {'kp': final_kp_dict, 'lines': final_lines_dict}
+
+                    json_data = json.dumps(final_dict)
+                    zip_file.writestr(f"{file.split('/')[-1].split('.')[0]}.json", json_data)
+
+
+
+
+
+

scripts/run_pipeline_sn22.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+# Set parameters
+ROOT_DIR="calibration/"
+SPLIT="test"
+CFG="config/hrnetv2_w48.yaml"
+CFG_L="config/hrnetv2_w48_l.yaml"
+WEIGHTS_KP="weights/SV_kp"
+WEIGHTS_L="weights/SV_lines"
+SAVE_DIR="inference/inference_3D/inference_sn22/"
+DEVICE="cuda:0"
+KP_TH=0.1611
+LINE_TH=0.3434
+MAX_REPROJ_ERR=57
+GT_FILE="${SAVE_DIR}${SPLIT}_main.zip"
+PRED_FILE="${SAVE_DIR}${SPLIT}_main_pred.zip"
+
+
+# Run inference script
+python scripts/inference_sn.py --cfg $CFG --cfg_l $CFG_L --weights_kp $WEIGHTS_KP --weights_line $WEIGHTS_L --root_dir $ROOT_DIR --split $SPLIT --save_dir $SAVE_DIR --kp_th $KP_TH --line_th $LINE_TH --max_reproj_err $MAX_REPROJ_ERR --cuda $DEVICE --main_cam_only
+
+# Run evaluation script
+python sn_calibration/src/evalai_camera.py -s $GT_FILE  -p $PRED_FILE 

scripts/run_pipeline_sn23.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+# Set parameters
+ROOT_DIR="datasets/calibration-2023/"
+SPLIT="test"
+CFG="config/hrnetv2_w48.yaml"
+CFG_L="config/hrnetv2_w48_l.yaml"
+WEIGHTS_KP="weights/MV_kp"
+WEIGHTS_L="weights/MV_lines"
+SAVE_DIR="inference/inference_3D/inference_sn23/"
+DEVICE="cuda:0"
+KP_TH=0.0712
+LINE_TH=0.2571
+MAX_REPROJ_ERR=38
+GT_FILE="${SAVE_DIR}${SPLIT}.zip"
+PRED_FILE="${SAVE_DIR}${SPLIT}_pred.zip"
+
+
+# Run inference script
+python scripts/inference_sn.py --cfg $CFG --cfg_l $CFG_L --weights_kp $WEIGHTS_KP --weights_line $WEIGHTS_L --root_dir $ROOT_DIR --split $SPLIT --save_dir $SAVE_DIR --kp_th $KP_TH --line_th $LINE_TH --max_reproj_err $MAX_REPROJ_ERR --cuda $DEVICE
+
+# Run evaluation script
+python sn_calibration/src/evalai_camera.py -s $GT_FILE  -p $PRED_FILE 

scripts/run_pipeline_tswc.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+# Set parameters
+ROOT_DIR="datasets/TS-WorldCup/"
+SPLIT="test"
+CFG="config/hrnetv2_w48.yaml"
+CFG_L="config/hrnetv2_w48_l.yaml"
+WEIGHTS_KP="weights/SV_FT_TSWC_kp"
+WEIGHTS_L="weights/SV_FT_TSWC_lines"
+SAVE_DIR="inference/inference_2D/inference_tswc/"
+KP_TH=0.2432
+LINE_TH=0.8482
+DEVICE="cuda:0"
+PRED_FILE="${SAVE_DIR}${SPLIT}_pred.zip"
+
+# Run inference script
+python scripts/inference_tswc.py --cfg $CFG --cfg_l $CFG_L --weights_kp $WEIGHTS_KP --weights_line $WEIGHTS_L --root_dir $ROOT_DIR --split $SPLIT --save_dir $SAVE_DIR --kp_th $KP_TH --line_th $LINE_TH --cuda $DEVICE
+
+# Run evaluation script
+python scripts/eval_tswc.py --root_dir $ROOT_DIR --split $SPLIT --pred_file $PRED_FILE

scripts/run_pipeline_wc14.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+# Set parameters
+ROOT_DIR="datasets/WC-2014/"
+SPLIT="test"
+CFG="config/hrnetv2_w48.yaml"
+CFG_L="config/hrnetv2_w48_l.yaml"
+WEIGHTS_KP="weights/SV_FT_WC14_kp"
+WEIGHTS_L="weights/SV_FT_WC14_lines"
+SAVE_DIR="inference/inference_2D/inference_wc14/"
+KP_TH=0.1274
+LINE_TH=0.1439
+DEVICE="cuda:0"
+PRED_FILE="${SAVE_DIR}${SPLIT}_pred.zip"
+
+# Run inference script
+python scripts/inference_wc14.py --cfg $CFG --cfg_l $CFG_L --weights_kp $WEIGHTS_KP --weights_line $WEIGHTS_L --root_dir $ROOT_DIR --split $SPLIT --save_dir $SAVE_DIR --kp_th $KP_TH --line_th $LINE_TH --cuda $DEVICE
+
+# Run evaluation script
+python scripts/eval_wc14.py --root_dir $ROOT_DIR --split $SPLIT --pred_file $PRED_FILE

scripts/run_pipeline_wc14_3D.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+# Set parameters
+ROOT_DIR="datasets/WC-2014/"
+SPLIT="test"
+CFG="config/hrnetv2_w48.yaml"
+CFG_L="config/hrnetv2_w48_l.yaml"
+WEIGHTS_KP="weights/SV_kp"
+WEIGHTS_L="weights/SV_lines"
+SAVE_DIR="inference/inference_3D/inference_wc14/"
+DEVICE="cuda:0"
+KP_TH=0.0070
+LINE_TH=0.1513
+MAX_REPROJ_ERR=83
+GT_FILE="${SAVE_DIR}${SPLIT}_main.zip"
+PRED_FILE="${SAVE_DIR}${SPLIT}_main_pred.zip"
+
+
+# Run inference script
+python scripts/inference_sn.py --cfg $CFG --cfg_l $CFG_L --weights_kp $WEIGHTS_KP --weights_line $WEIGHTS_L --root_dir $ROOT_DIR --split $SPLIT --save_dir $SAVE_DIR --kp_th $KP_TH --line_th $LINE_TH --max_reproj_err $MAX_REPROJ_ERR --cuda $DEVICE --main_cam_only
+
+# Run evaluation script
+python sn_calibration/src/evalai_camera.py -s $GT_FILE  -p $PRED_FILE 

sn_calibration/ChallengeRules.md

@@ -0,0 +1,44 @@
+# Guidelines for the Calibration challenge
+
+The 2nd [Calibration challenge]() will be held at the 
+official [CVSports Workshop](https://vap.aau.dk/cvsports/) at CVPR 2023! 
+Subscribe (watch) the repo to receive the latest info regarding timeline and prizes!
+
+We provide an [evaluation server](https://eval.ai/web/challenges/challenge-page/1946/overview) for anyone competing in the challenge. 
+This evaluation server handles predictions for the open **test** set and the segregated **challenge** set.
+
+Winners will be announced at CVSports Workshop at CVPR 2022. 
+Prizes 💲💲💲 include $1000 cash award, sponsored by [EVS Broadcast Equipment](https://evs.com/).
+
+
+## Who can participate / How to participate?
+
+ - Any individual can participate to the challenge, except the organizers.
+ - The participants are recommended to form a team to participate.
+ - Each team can have one or more members. 
+ - An individual/team can compete on both task.
+ - An individual associated with multiple teams (for a given task) or a team with multiple accounts will be disqualified.
+ - On both task, a particpant can only use the images as input.
+ - A particpant is allowed to extract its own visual/audio features with any pre-trained model.
+
+## How to win / What is the prize?
+
+ - For each task, the winner is the individual/team who reach the highest performance on the **challenge** set.
+ - The metrics taken into consideration is the combined metric: completeness * Accuracy@5.
+ - The deadline to submit your results is May 30th at 11.59 pm  Pacific Time.
+ - The teams that perform best will be granted $1000 from our sponsor [EVS Broadcast Equipment](https://evs.com/).
+ - In order to be eligible for the prize, we require the individual/team to provide a short report describing the details of the methodology (CVPR format, max 2 pages)
+
+
+
+## Important dates
+
+Note that these dates are tentative and subject to changes if necessary.
+
+ - **February 1:** Open evaluation server on the (Open) Test set.
+ - **February 15:** Open evaluation server on the (Seggregated) Challenge set.
+ - **May 30:** Close evaluation server.
+ - **June 6:** Deadline for submitting the report.
+ - **June 19:** A full-day workshop at CVPR 2023.
+
+For any further doubt or concern, please raise an issue in that repository, or contact us directly on [Discord](https://discord.gg/SM8uHj9mkP).

sn_calibration/README.md

@@ -0,0 +1,440 @@
+
+![](./doc/EVS_LOGO_COLOUR_RGB.png)
+
+# EVS Camera Calibration Challenge
+
+
+Welcome to the EVS camera calibration challenge ! This challenge is sponsored by EVS Broadcast Equipment, and is
+developped in collaboration with the SoccerNet team.
+
+This challenge consists of two distinct tasks which are defined hereafter. We provide sample code and baselines for each
+task to help you get started!
+
+
+Participate in our upcoming Challenge at the [CVSports](https://vap.aau.dk/cvsports/) workshop at CVPR and try to win up to 1000$ sponsored by [EVS](https://evs.com/)! All details are available on the [challenge website](https://eval.ai/web/challenges/challenge-page/1537/overview ), or on the [main page](https://www.soccer-net.org/).
+
+The participation deadline is fixed at the 30th of May 2023. The official rules and guidelines are available on [ChallengeRules.md](ChallengeRules.md).
+
+<a href="https://www.youtube.com/watch?v=nxywN6X_0oE">
+<p align="center"><img src="images/Thumbnail.png" width="720"></p>
+</a>
+
+### 2023 Leaderboard
+
+<p><table class="dataframe">
+  <thead>
+    <tr style="text-align: right;">
+      <th style = "background-color: #FFFFFF;font-family: Century Gothic, sans-serif;font-size: medium;color: #305496;text-align: left;border-bottom: 2px solid #305496;padding: 0px 20px 0px 0px;width: auto">Team</th>
+      <th style = "background-color: #FFFFFF;font-family: Century Gothic, sans-serif;font-size: medium;color: #305496;text-align: left;border-bottom: 2px solid #305496;padding: 0px 20px 0px 0px;width: auto">Combined Metric</th>
+      <th style = "background-color: #FFFFFF;font-family: Century Gothic, sans-serif;font-size: medium;color: #305496;text-align: left;border-bottom: 2px solid #305496;padding: 0px 20px 0px 0px;width: auto">Accuracy@5</th>
+      <th style = "background-color: #FFFFFF;font-family: Century Gothic, sans-serif;font-size: medium;color: #305496;text-align: left;border-bottom: 2px solid #305496;padding: 0px 20px 0px 0px;width: auto">Completeness</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td style = "background-color: #D9E1F2;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">Sportlight</td>
+      <td style = "background-color: #D9E1F2;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">0.55</td>
+      <td style = "background-color: #D9E1F2;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">73.22</td>
+      <td style = "background-color: #D9E1F2;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">75.59</td>
+    </tr>
+    <tr>
+      <td style = "background-color: white; color: black;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">Spiideo</td>
+      <td style = "background-color: white; color: black;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">0.53</td>
+      <td style = "background-color: white; color: black;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">52.95</td>
+      <td style = "background-color: white; color: black;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">99.96</td>
+    </tr>
+    <tr>
+      <td style = "background-color: #D9E1F2;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">SAIVA_Calibration</td>
+      <td style = "background-color: #D9E1F2;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">0.53</td>
+      <td style = "background-color: #D9E1F2;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">60.33</td>
+      <td style = "background-color: #D9E1F2;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">87.22</td>
+    </tr>
+    <tr>
+      <td style = "background-color: white; color: black;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">BPP</td>
+      <td style = "background-color: white; color: black;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">0.5</td>
+      <td style = "background-color: white; color: black;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">69.12</td>
+      <td style = "background-color: white; color: black;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">72.54</td>
+    </tr>
+    <tr>
+      <td style = "background-color: #D9E1F2;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">ikapetan</td>
+      <td style = "background-color: #D9E1F2;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">0.43</td>
+      <td style = "background-color: #D9E1F2;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">53.78</td>
+      <td style = "background-color: #D9E1F2;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">79.71</td>
+    </tr>
+    <tr>
+      <td style = "background-color: white; color: black;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">NASK</td>
+      <td style = "background-color: white; color: black;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">0.41</td>
+      <td style = "background-color: white; color: black;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">53.01</td>
+      <td style = "background-color: white; color: black;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">77.81</td>
+    </tr>
+    <tr>
+      <td style = "background-color: #D9E1F2;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">Mike Azatov and Jonas Theiner</td>
+      <td style = "background-color: #D9E1F2;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">0.41</td>
+      <td style = "background-color: #D9E1F2;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">58.61</td>
+      <td style = "background-color: #D9E1F2;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">69.34</td>
+    </tr>
+    <tr>
+      <td style = "background-color: white; color: black;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">Baseline</td>
+      <td style = "background-color: white; color: black;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">0.08</td>
+      <td style = "background-color: white; color: black;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">13.54</td>
+      <td style = "background-color: white; color: black;font-family: Century Gothic, sans-serif;font-size: medium;text-align: left;padding: 0px 20px 0px 0px;width: auto">61.54</td>
+    </tr>
+  </tbody>
+</table></p>
+
+## Table of content
+
+- Install
+- Dataset
+    - Soccer pitch annotations
+- Camera calibration
+    - Definition
+    - Evaluation
+    - Baseline
+
+## Install
+
+Download the network weights from google drive https://drive.google.com/file/d/1dbN7LdMV03BR1Eda8n7iKNIyYp9r07sM/view?usp=sharing 
+and place them in [resources](resources).
+
+With python 3 already installed, the python environment can be installed with the following command:
+
+```
+pip install -r requirements.txt
+```
+
+## Dataset
+
+SoccerNet is a dataset containing 400 broadcasted videos of whole soccer games. The dataset can be found
+here :   https://soccer-net.org/
+The authors give access to template code and a python package to get started with the dataset. All the documentation
+about these tools can be found here : https://github.com/SilvioGiancola/SoccerNetv2-DevKit
+
+All the data needed for challenge can be downloaded with these lines : 
+
+```python
+from SoccerNet.Downloader import SoccerNetDownloader as SNdl
+soccerNetDownloader = SNdl(LocalDirectory="path/to/SoccerNet")
+soccerNetDownloader.downloadDataTask(task="calibration-2023", split=["train","valid","test","challenge"])
+```
+
+Historically, the dataset was first released for an action spotting task. In its first version, the images corresponding
+to soccer actions (goals, fouls, etc) were identified. In the following editions, more annotations have been associated
+to those images. In the last version of the dataset (SoccerNetV3), the extremities of the lines of the soccer pitch
+markings have been annotated. As a partnership with SoccerNet's team, we use these annotations in a new challenge. The
+challenge is divided in two tasks, the resolution of the first leading to the second one. The first is a soccer pitch
+element localisation task which can then be used for the second task which is a camera calibration task.
+
+**/!\ New** : some annotations have been added: for some images, there are new points annotation along the pitch markings lines.
+For straight pitch marking lines, you can always assume that the extremities are annotated, and sometimes, 
+if the image has been reannotated, there will be a few extra points along the imaged line. 
+
+
+### Soccer pitch annotations
+
+Performing camera calibration can be eased by the presence of an object with a known shape in the image. For soccer
+content, the soccer pitch can be used as a target for the camera calibration because it has a known shape and its
+dimensions are specified in the International Football Association Board's law of the
+game (https://digitalhub.fifa.com/m/5371a6dcc42fbb44/original/d6g1medsi8jrrd3e4imp-pdf.pdf).
+
+Moreover, we define a set of semantic labels for each semantic element of the soccer pitch. We also define the bottom
+side of the pitch as the one where the main and 16 meters broadcast cameras are installed.
+
+![](./doc/soccernet_classes.png)
+
+1. Big rect. left bottom,
+2. Big rect. left main,
+3. Big rect. left top,
+4. Big rect. right bottom,
+5. Big rect. right main,
+6. Big rect. right top,
+7. Circle central,
+8. Circle left,
+9. Circle right,
+10. Goal left crossbar,
+11. Goal left post left ,
+12. Goal left post right,
+13. Goal right crossbar,
+14. Goal right post left,
+15. Goal right post right,
+16. Middle line,
+17. Side line bottom,
+18. Side line left,
+19. Side line right,
+20. Side line top,
+21. Small rect. left bottom,
+22. Small rect. left main,
+23. Small rect. left top,
+24. Small rect. right bottom,
+25. Small rect. right main,
+26. Small rect. right top
+
+In the third version of SoccerNet, there are new annotations for each image of the dataset. These new annotations
+consists in the list of all extremities of the semantic elements of the pitch present in the image. The extremities are
+a pair of 2D point coordinates.
+
+For the circles drawn on the pitch, the annotations consist in a list of points which give roughly the shape of the
+circle when connected. Note that due to new annotations, the sequential order of circle points is no longer guaranteed. 
+
+
+
+##  Camera calibration task
+
+As a soccer pitch has known dimensions, it is possible to use the soccer pitch as a calibration target in order to
+calibrate the camera. Since the pitch is roughly planar, we can model the transformation applied by the camera to the pitch by a
+homography. In order to estimate the homography between the pitch and its image, we only need 4 lines. We provide a
+baseline in order to extract camera parameters from this kind of images.
+
+### Definition
+
+In this task, we ask you to provide valid camera parameters for each image of the challenge set.
+
+Given a common 3D pitch template, we will use the camera parameters produced by your algorithm in order to estimate the
+reprojection error induced by the camera parameters. The camera parameters include its lens parameters, its orientation,
+its translation with respect to the world reference axis system that we define accordingly:
+
+![](./doc/axis-system-resized.jpeg)
+
+#### Rotation convention
+
+Following Euler angles convention, we use a ZXZ succession of intrinsic rotations in order to describe the orientation
+of the camera. Starting from the world reference axis system, we first apply a rotation around the Z axis to pan the
+camera. Then the obtained axis system is rotated around its x axis in order to tilt the camera. Then the last rotation
+around the z axis of the new axis system allows to roll the camera. Note that this z axis is the principal axis of the
+camera.
+
+The lens parameters produced must follow the pinhole model. Additionally, the parameters can include radial, tangential
+and thin prism distortion parameters. This corresponds to the full model of
+OpenCV : https://docs.opencv.org/4.5.0/d9/d0c/group__calib3d.html#details
+
+For each image of the test set, we expect to receive a json file named "**camera_{frame_index}.json**" containing a
+dictionary with the camera parameters. 
+
+```
+# camera_00001.json
+ {
+      "pan_degrees": 14.862476218376278,
+      "tilt_degrees": 78.83988009048775,
+      "roll_degrees": -2.2210919345134497,
+      "position_meters": [
+          32.6100008989567,
+          67.9363036953344,
+          -14.898134157887508
+      ],
+      "x_focal_length": 3921.6013418112757,
+      "y_focal_length": 3921.601341812138,
+      "principal_point": [
+          480.0,
+          270.0
+      ],
+      "radial_distortion": [
+          0.0,
+          0.0,
+          0.0,
+          0.0,
+          0.0,
+          0.0
+      ],
+      "tangential_distortion": [
+          0.0,
+          0.0
+      ],
+      "thin_prism_distortion": [
+          0.0,
+          0.0,
+          0.0,
+          0.0
+      ]
+ }
+```
+
+The results should be organized as follows :
+
+
+```
+test.zip
+|__ camera_00001.json
+|__ camera_00002.json
+```
+
+
+### Evaluation
+
+We only evaluate the quality of the camera parameters provided in the image world, as it is the only groundtruth that we
+have. The annotated points are either extremities or points on circles, and thus they do not always have a mapping to a
+3D point, but we can always map them to lines or circles.
+
+#### Dealing with ambiguities
+
+The dataset contains some ambiguities when we consider each image independently. Without context, one can't know if a
+camera behind a goal is on the left or the right side of the pitch.
+
+For example, this image taken by a camera behind the goal :
+
+![](./doc/tactical_amibguity_resized.jpeg)
+
+It is impossible to say without any context if it was shot by the camera whose filming range is in blue or in yellow.
+
+![](./doc/ambiguity_soccernet_resized.jpeg)
+
+Therefore, we take this ambiguity into account in the evaluation and we consider both accuracy for the groundtruth
+label, and the accuracy for the central projection by the pitch center of the labels. The higher accuracy will be
+selected for your evaluation.
+
+
+We evaluate the best submission based on the accuracy at a specific threshold distance. This metric is explained
+hereunder.
+
+#### Accuracy @ threshold
+
+The evaluation is based on the reprojection error which we define here as the L2 distance between one annotated point
+and the line to which the point belong. This metric does not account well for false positives and false negatives
+(hallucinated/missing lines projections). Thus we formulate our evaluation as a binary classification, with a
+distance threshold with a twist : this time, we consider a pitch marking to be one entity, and for it to be correctly
+detected, all its extremities (or all points annotated for circles) must have a reprojection error smaller than the
+threshold.
+
+As we allow lens distortion, the projection of the pitch line markings can be curvated. This is why we sample the pitch
+model every few centimeters, and we consider that the distance between a projected pitch marking and a groundtruth point is in
+fact the euclidian distance between the groundtruth point and the polyline given by the projection of sampled points.
+
+* True positives : for classes that belong both to the prediction and the groundtruth, a predicted element is a True
+  Positive if all the L2 distances between its groundtruth points and the predicted polyline are lower than a
+  certain threshold.
+
+  ![](./doc/tp-condition-2.png)
+
+* False positives : contains elements that were detected with a class that do not belong to the groundtruth classes, and
+  elements with valid classes which are distant from at least **t** pixels from one of the groundtruth points associated
+  to the element.
+* False negatives: Line elements only present in the groundtruth are counted as False Negatives.
+* True negatives : There are no True Negatives.
+
+The Accuracy for a threshold of t pixels is given by : **Acc@t = TP/(TP+FN+FP)**. We evaluate the accuracy at 5 pixels. 
+We only use images with predicted camera parameters in this evaluation.
+
+#### Completeness rate
+
+We also measure the completeness rate as the number of camera parameters provided divided by the number of images with
+more than four semantic line annotations in the dataset.
+
+#### Final score 
+
+The evaluation criterion for a camera calibration method is the following : **Completeness x Acc@5**
+
+#### Per class information
+
+The global accuracy described above has the advantage to treat all soccer pitch marking types equivalently even if the
+groundtruth contains more annotated points for a specific class. For instance, a circle is annotated with 9 points on
+average, whilst rectilinear elements have usually two points annotated. But this metric might be harder as we consider
+all points annotated instead of each of them independently. This is precisely why we propose this per class metric, that
+accounts for each point annotated separately. This metric is only for information purposes and will not be used in the
+ranking of submissions.
+
+The prediction is obtained by sampling each 3D real world pitch element every few centimeters, which means that the
+number of points in the prediction may be variable for the same camera parameters. This gives a very high number of 
+predicted points for a certain class, and thus we find a workaround to count false positives.
+
+The confusion matrices are computed per class in the following way :
+
+* True positives : for classes that belong both to the prediction and the groundtruth, a predicted point is counted in
+  the True Positives if the L2 distance from this groundtruth point to the predicted polyline is lower than a
+  certain threshold **t**.
+
+* False positives : counts groundtruth points that have a distance to the corresponding predicted polyline that is higher
+  than the threshold value **t**. For predicted lines that do not belong to the groundtruth, we can not count every
+  predicted point as a false positive because the number of points depend on the sampling factor that has to be high
+  enough, which can lower a lot our metric. We decided arbitrarily to count for this kind of false positive the number
+  of points that a human annotator would have annotated for this class, i.e. two points for rectilinear elements and 9
+  for circle elements. 
+* False negatives: All groundtruth points whose class is only present in the groundtruth are counted as False Negatives.
+* True negatives : There are no True Negatives.
+
+The Accuracy for a threshold of t pixels is given by : **Acc@t = TP/(TP+FN+FP)**. We evaluate the accuracy at 5, 10 and
+20 pixels. We only use images with predicted camera parameters in this evaluation.
+
+
+### Baseline
+
+#### Method
+
+For our camera calibration baseline, we proceed in two steps: first we find the pitch markings location in the image, 
+and then given our pitch marking correspondences, we estimate camera parameters.
+
+For this first step, we decided to locate the pitch markings with a neural network trained to perform semantic line 
+segmentation. We used DeepLabv3 architecture. The target semantic segmentation masks were generated by joining 
+successively all the points annotated for each line in the image. We provide the dataloader that we used for the 
+training in the src folder.
+
+The segmentation maps predicted by the neural
+network are further processed in order to get the line extremities. First, for each class, we fit circles on the
+segmentation mask. All pixels belonging to a same class are thus synthesized by a set of points (i.e. circles centers).
+Then we build polylines based on the circles centers : all the points that are close enough are considered to belong to
+the same polyline. Finally the extremities of each line class will be the extremities of the longest polyline for that
+line class.
+
+You can test the line detection with the following code:
+
+```
+python src/detect_extremities.py -s <path_to_soccernet_dataset> -p <path_to_store_predictions>
+```
+
+
+In the second step, we use the extremities of the lines (
+not Circles) detected in the image in order to estimate an homography from the soccer pitch model to the image. We
+provide a class **soccerpitch.py** to define the pitch model according to the rules of the game. The homography is then
+decomposed in camera parameters. All aspects concerning camera parameters are located in the **camera.py**, including
+homography decomposition in rotation and translation matrices, including calibration matrix estimation from the
+homography, functions for projection...
+
+You can test the baseline with the following line : 
+
+```python src/baseline_cameras.py -s <path to soccernet dataset> -p <path to 1st task prediction>``` 
+
+And to test the evaluation, you can run :
+
+`python src/evaluate_camera.py -s  <path to soccernet dataset> -p <path to predictions> -t <threshold value>`
+
+
+#### Results
+
+| Acc@t    | Acc@5 | Completeness | Final score | 
+|----------|-------|--------------|-------------|
+| Baseline | 11.7% | 68%          | 7.96%       |
+
+#### Improvements
+
+The baseline could be directly improved by :
+
+* exploiting the masks rather than the extremities prediction of the first baseline
+* using ransac to estimate the homography
+* refining the camera parameters using line and ellipses correspondences.
+
+## Citation
+For further information check out the paper and supplementary material:
+https://arxiv.org/abs/2210.02365
+
+Please cite our work if you use the SoccerNet dataset:
+```bibtex
+@inproceedings{Giancola_2022,
+	doi = {10.1145/3552437.3558545},
+	url = {https://doi.org/10.1145%2F3552437.3558545},
+	year = 2022,
+	month = {oct},
+	publisher = {{ACM}},
+	author = {Silvio Giancola and Anthony Cioppa and Adrien Deli{\`{e}}ge and Floriane Magera and Vladimir Somers and Le Kang and Xin Zhou and Olivier Barnich and Christophe De Vleeschouwer and Alexandre Alahi and Bernard Ghanem and Marc Van Droogenbroeck and Abdulrahman Darwish and Adrien Maglo and Albert Clap{\'{e}}s and Andreas Luyts and Andrei Boiarov and Artur Xarles and Astrid Orcesi and Avijit Shah and Baoyu Fan and Bharath Comandur and Chen Chen and Chen Zhang and Chen Zhao and Chengzhi Lin and Cheuk-Yiu Chan and Chun Chuen Hui and Dengjie Li and Fan Yang and Fan Liang and Fang Da and Feng Yan and Fufu Yu and Guanshuo Wang and H. Anthony Chan and He Zhu and Hongwei Kan and Jiaming Chu and Jianming Hu and Jianyang Gu and Jin Chen and Jo{\~{a}}o V. B. Soares and Jonas Theiner and Jorge De Corte and Jos{\'{e}} Henrique Brito and Jun Zhang and Junjie Li and Junwei Liang and Leqi Shen and Lin Ma and Lingchi Chen and Miguel Santos Marques and Mike Azatov and Nikita Kasatkin and Ning Wang and Qiong Jia and Quoc Cuong Pham and Ralph Ewerth and Ran Song and Rengang Li and Rikke Gade and Ruben Debien and Runze Zhang and Sangrok Lee and Sergio Escalera and Shan Jiang and Shigeyuki Odashima and Shimin Chen and Shoichi Masui and Shouhong Ding and Sin-wai Chan and Siyu Chen and Tallal El-Shabrawy and Tao He and Thomas B. Moeslund and Wan-Chi Siu and Wei Zhang and Wei Li and Xiangwei Wang and Xiao Tan and Xiaochuan Li and Xiaolin Wei and Xiaoqing Ye and Xing Liu and Xinying Wang and Yandong Guo and Yaqian Zhao and Yi Yu and Yingying Li and Yue He and Yujie Zhong and Zhenhua Guo and Zhiheng Li},
+	title = {{SoccerNet} 2022 Challenges Results},
+	booktitle = {Proceedings of the 5th International {ACM} Workshop on Multimedia Content Analysis in Sports}
+}
+```
+
+
+
+## Our other Challenges
+
+Check out our other challenges related to SoccerNet!
+- [Action Spotting](https://github.com/SoccerNet/sn-spotting)
+- [Replay Grounding](https://github.com/SoccerNet/sn-grounding)
+- [Calibration](https://github.com/SoccerNet/sn-calibration)
+- [Re-Identification](https://github.com/SoccerNet/sn-reid)
+- [Tracking](https://github.com/SoccerNet/sn-tracking)

sn_calibration/requirements.txt

@@ -0,0 +1,17 @@
+# numpy~>1.21
+# torch~=1.10.0
+# torchvision~=0.11.1
+# pillow~>9.0.0
+# tqdm~=4.62.3
+# SoccerNet>=0.1.23
+# opencv-python~=4.5.5
+# matplotlib~=3.5.1
+
+numpy>=1.21
+torch>=2.0.0
+torchvision>=0.15.0
+pillow>=9.0.0
+tqdm~=4.62.3
+SoccerNet>=0.1.23
+opencv-python~=4.5.5
+matplotlib~=3.5.1

sn_calibration/resources/mean.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8dcd1f96b2486853498b6e38a0eb344cda9c272cd0fe87adb84ec0a09e244a36
+size 152

sn_calibration/resources/std.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:49dac1cfa5ab2f197a64332c4fd7dc08335dd46d31244acc0e4a03686241fe79
+size 152

sn_calibration/src/baseline_cameras.py

@@ -0,0 +1,251 @@
+import argparse
+import json
+import os
+
+import cv2 as cv
+import numpy as np
+from tqdm import tqdm
+
+from src.camera import Camera
+from src.soccerpitch import SoccerPitch
+
+
+def normalization_transform(points):
+    """
+    Computes the similarity transform such that the list of points is centered around (0,0) and that its distance to the
+    center is sqrt(2).
+    :param points: point cloud that we wish to normalize
+    :return: the affine transformation matrix
+    """
+    center = np.mean(points, axis=0)
+
+    d = 0.
+    nelems = 0
+    for p in points:
+        nelems += 1
+        x = p[0] - center[0]
+        y = p[1] - center[1]
+        di = np.sqrt(x ** 2 + y ** 2)
+        d += (di - d) / nelems
+
+    if d <= 0.:
+        s = 1.
+    else:
+        s = np.sqrt(2) / d
+    T = np.zeros((3, 3))
+    T[0, 0] = s
+    T[0, 2] = -s * center[0]
+    T[1, 1] = s
+    T[1, 2] = -s * center[1]
+    T[2, 2] = 1
+    return T
+
+
+def estimate_homography_from_line_correspondences(lines, T1=np.eye(3), T2=np.eye(3)):
+    """
+    Given lines correspondences, computes the homography that maps best the two set of lines.
+    :param lines: list of pair of 2D lines matches.
+    :param T1: Similarity transform to normalize the elements of the source reference system
+    :param T2: Similarity transform to normalize the elements of the target reference system
+    :return: boolean to indicate success or failure of the estimation, homography
+    """
+    homography = np.eye(3)
+    A = np.zeros((len(lines) * 2, 9))
+
+    for i, line_pair in enumerate(lines):
+        src_line = np.transpose(np.linalg.inv(T1)) @ line_pair[0]
+        target_line = np.transpose(np.linalg.inv(T2)) @ line_pair[1]
+        u = src_line[0]
+        v = src_line[1]
+        w = src_line[2]
+
+        x = target_line[0]
+        y = target_line[1]
+        z = target_line[2]
+
+        A[2 * i, 0] = 0
+        A[2 * i, 1] = x * w
+        A[2 * i, 2] = -x * v
+        A[2 * i, 3] = 0
+        A[2 * i, 4] = y * w
+        A[2 * i, 5] = -v * y
+        A[2 * i, 6] = 0
+        A[2 * i, 7] = z * w
+        A[2 * i, 8] = -v * z
+
+        A[2 * i + 1, 0] = x * w
+        A[2 * i + 1, 1] = 0
+        A[2 * i + 1, 2] = -x * u
+        A[2 * i + 1, 3] = y * w
+        A[2 * i + 1, 4] = 0
+        A[2 * i + 1, 5] = -u * y
+        A[2 * i + 1, 6] = z * w
+        A[2 * i + 1, 7] = 0
+        A[2 * i + 1, 8] = -u * z
+
+    try:
+        u, s, vh = np.linalg.svd(A)
+    except np.linalg.LinAlgError:
+        return False, homography
+    v = np.eye(3)
+    has_positive_singular_value = False
+    for i in range(s.shape[0] - 1, -2, -1):
+        v = np.reshape(vh[i], (3, 3))
+
+        if s[i] > 0:
+            has_positive_singular_value = True
+            break
+
+    if not has_positive_singular_value:
+        return False, homography
+
+    homography = np.reshape(v, (3, 3))
+    homography = np.linalg.inv(T2) @ homography @ T1
+    homography /= homography[2, 2]
+
+    return True, homography
+
+
+def draw_pitch_homography(image, homography):
+    """
+    Draws points along the soccer pitch markings elements in the image based on the homography projection.
+    /!\ This function assumes that the resolution of the image is 540p.
+    :param image
+    :param homography: homography that captures the relation between the world pitch plane and the image
+    :return: modified image
+    """
+    field = SoccerPitch()
+    polylines = field.sample_field_points()
+    for line in polylines.values():
+
+        for point in line:
+            if point[2] == 0.:
+                hp = np.array((point[0], point[1], 1.))
+                projected = homography @ hp
+                if projected[2] == 0.:
+                    continue
+                projected /= projected[2]
+                if 0 < projected[0] < 960 and 0 < projected[1] < 540:
+                    cv.circle(image, (int(projected[0]), int(projected[1])), 1, (255, 0, 0), 1)
+
+    return image
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser(description='Baseline for camera parameters extraction')
+
+    parser.add_argument('-s', '--soccernet', default="/home/fmg/data/SN23/calibration-2023-bis/", type=str,
+                        help='Path to the SoccerNet-V3 dataset folder')
+    parser.add_argument('-p', '--prediction', default="/home/fmg/results/SN23-tests/",
+                        required=False, type=str,
+                        help="Path to the prediction folder")
+    parser.add_argument('--split', required=False, type=str, default="valid", help='Select the split of data')
+    parser.add_argument('--resolution_width', required=False, type=int, default=960,
+                        help='width resolution of the images')
+    parser.add_argument('--resolution_height', required=False, type=int, default=540,
+                        help='height resolution of the images')
+    args = parser.parse_args()
+
+    field = SoccerPitch()
+
+    dataset_dir = os.path.join(args.soccernet, args.split)
+    if not os.path.exists(dataset_dir):
+        print("Invalid dataset path !")
+        exit(-1)
+
+    with open(os.path.join(dataset_dir, "per_match_info.json"), 'r') as f:
+        match_info = json.load(f)
+
+    with tqdm(enumerate(match_info.keys()), total=len(match_info.keys()), ncols=160) as t:
+        for i, match in t:
+            frame_list = match_info[match].keys()
+
+            for frame in frame_list:
+                frame_index = frame.split(".")[0]
+                prediction_file = os.path.join(args.prediction, args.split, f"extremities_{frame_index}.json")
+
+                if not os.path.exists(prediction_file):
+                    continue
+
+                with open(prediction_file, 'r') as f:
+                    predictions = json.load(f)
+
+                camera_predictions = dict()
+                image_path = os.path.join(dataset_dir, frame)
+                # cv_image = cv.imread(image_path)
+                # cv_image = cv.resize(cv_image, (args.resolution_width, args.resolution_height))
+
+                line_matches = []
+                potential_3d_2d_matches = {}
+                src_pts = []
+                success = False
+                for k, v in predictions.items():
+                    if k == 'Circle central' or "unknown" in k:
+                        continue
+                    P3D1 = field.line_extremities_keys[k][0]
+                    P3D2 = field.line_extremities_keys[k][1]
+                    p1 = np.array([v[0]['x'] * args.resolution_width, v[0]['y'] * args.resolution_height, 1.])
+                    p2 = np.array([v[1]['x'] * args.resolution_width, v[1]['y'] * args.resolution_height, 1.])
+                    src_pts.extend([p1, p2])
+                    if P3D1 in potential_3d_2d_matches.keys():
+                        potential_3d_2d_matches[P3D1].extend([p1, p2])
+                    else:
+                        potential_3d_2d_matches[P3D1] = [p1, p2]
+                    if P3D2 in potential_3d_2d_matches.keys():
+                        potential_3d_2d_matches[P3D2].extend([p1, p2])
+                    else:
+                        potential_3d_2d_matches[P3D2] = [p1, p2]
+
+                    start = (int(p1[0]), int(p1[1]))
+                    end = (int(p2[0]), int(p2[1]))
+                    # cv.line(cv_image, start, end, (0, 0, 255), 1)
+
+                    line = np.cross(p1, p2)
+                    if np.isnan(np.sum(line)) or np.isinf(np.sum(line)):
+                        continue
+                    line_pitch = field.get_2d_homogeneous_line(k)
+                    if line_pitch is not None:
+                        line_matches.append((line_pitch, line))
+
+                if len(line_matches) >= 4:
+                    target_pts = [field.point_dict[k][:2] for k in potential_3d_2d_matches.keys()]
+                    T1 = normalization_transform(target_pts)
+                    T2 = normalization_transform(src_pts)
+                    success, homography = estimate_homography_from_line_correspondences(line_matches, T1, T2)
+                    if success:
+                        # cv_image = draw_pitch_homography(cv_image, homography)
+
+                        cam = Camera(args.resolution_width, args.resolution_height)
+                        success = cam.from_homography(homography)
+                        if success:
+                            point_matches = []
+                            added_pts = set()
+                            for k, potential_matches in potential_3d_2d_matches.items():
+                                p3D = field.point_dict[k]
+                                projected = cam.project_point(p3D)
+
+                                if 0 < projected[0] < args.resolution_width and 0 < projected[
+                                    1] < args.resolution_height:
+                                    dist = np.zeros(len(potential_matches))
+                                    for i, potential_match in enumerate(potential_matches):
+                                        dist[i] = np.sqrt((projected[0] - potential_match[0]) ** 2 + (
+                                                projected[1] - potential_match[1]) ** 2)
+                                    selected = np.argmin(dist)
+                                    if dist[selected] < 100:
+                                        point_matches.append((p3D, potential_matches[selected][:2]))
+
+                            if len(point_matches) > 3:
+                                cam.refine_camera(point_matches)
+                                # cam.draw_colorful_pitch(cv_image, SoccerField.palette)
+                                # print(image_path)
+                                # cv.imshow("colorful pitch", cv_image)
+                                # cv.waitKey(0)
+
+                if success:
+                    camera_predictions = cam.to_json_parameters()
+
+                task2_prediction_file = os.path.join(args.prediction, args.split, f"camera_{frame_index}.json")
+                if camera_predictions:
+                    with open(task2_prediction_file, "w") as f:
+                        json.dump(camera_predictions, f, indent=4)

sn_calibration/src/camera.py

@@ -0,0 +1,402 @@
+import cv2 as cv
+import numpy as np
+
+from soccerpitch import SoccerPitch
+
+
+def pan_tilt_roll_to_orientation(pan, tilt, roll):
+    """
+    Conversion from euler angles to orientation matrix.
+    :param pan:
+    :param tilt:
+    :param roll:
+    :return: orientation matrix
+    """
+    Rpan = np.array([
+        [np.cos(pan), -np.sin(pan), 0],
+        [np.sin(pan), np.cos(pan), 0],
+        [0, 0, 1]])
+    Rroll = np.array([
+        [np.cos(roll), -np.sin(roll), 0],
+        [np.sin(roll), np.cos(roll), 0],
+        [0, 0, 1]])
+    Rtilt = np.array([
+        [1, 0, 0],
+        [0, np.cos(tilt), -np.sin(tilt)],
+        [0, np.sin(tilt), np.cos(tilt)]])
+    rotMat = np.dot(Rpan, np.dot(Rtilt, Rroll))
+    return rotMat
+
+
+def rotation_matrix_to_pan_tilt_roll(rotation):
+    """
+    Decomposes the rotation matrix into pan, tilt and roll angles. There are two solutions, but as we know that cameramen
+    try to minimize roll, we take the solution with the smallest roll.
+    :param rotation: rotation matrix
+    :return: pan, tilt and roll in radians
+    """
+    orientation = np.transpose(rotation)
+    first_tilt = np.arccos(orientation[2, 2])
+    second_tilt = - first_tilt
+
+    sign_first_tilt = 1. if np.sin(first_tilt) > 0. else -1.
+    sign_second_tilt = 1. if np.sin(second_tilt) > 0. else -1.
+
+    first_pan = np.arctan2(sign_first_tilt * orientation[0, 2], sign_first_tilt * - orientation[1, 2])
+    second_pan = np.arctan2(sign_second_tilt * orientation[0, 2], sign_second_tilt * - orientation[1, 2])
+    first_roll = np.arctan2(sign_first_tilt * orientation[2, 0], sign_first_tilt * orientation[2, 1])
+    second_roll = np.arctan2(sign_second_tilt * orientation[2, 0], sign_second_tilt * orientation[2, 1])
+
+    # print(f"first solution {first_pan*180./np.pi}, {first_tilt*180./np.pi}, {first_roll*180./np.pi}")
+    # print(f"second solution {second_pan*180./np.pi}, {second_tilt*180./np.pi}, {second_roll*180./np.pi}")
+    if np.fabs(first_roll) < np.fabs(second_roll):
+        return first_pan, first_tilt, first_roll
+    return second_pan, second_tilt, second_roll
+
+
+def unproject_image_point(homography, point2D):
+    """
+    Given the homography from the world plane of the pitch and the image and a point localized on the pitch plane in the
+    image, returns the coordinates of the point in the 3D pitch plane.
+    /!\ Only works for correspondences on the pitch (Z = 0).
+    :param homography: the homography
+    :param point2D: the image point whose relative coordinates on the world plane of the pitch are to be found
+    :return: A 2D point on the world pitch plane in homogenous coordinates (X,Y,1) with X and Y being the world
+    coordinates of the point.
+    """
+    hinv = np.linalg.inv(homography)
+    pitchpoint = hinv @ point2D
+    pitchpoint = pitchpoint / pitchpoint[2]
+    return pitchpoint
+
+
+class Camera:
+
+    def __init__(self, iwidth=960, iheight=540):
+        self.position = np.zeros(3)
+        self.rotation = np.eye(3)
+        self.calibration = np.eye(3)
+        self.radial_distortion = np.zeros(6)
+        self.thin_prism_disto = np.zeros(4)
+        self.tangential_disto = np.zeros(2)
+        self.image_width = iwidth
+        self.image_height = iheight
+        self.xfocal_length = 1
+        self.yfocal_length = 1
+        self.principal_point = (self.image_width / 2, self.image_height / 2)
+
+    def solve_pnp(self, point_matches):
+        """
+        With a known calibration matrix, this method can be used in order to retrieve rotation and translation camera
+        parameters.
+        :param point_matches: A list of pairs of 3D-2D point matches .
+        """
+        target_pts = np.array([pt[0] for pt in point_matches])
+        src_pts = np.array([pt[1] for pt in point_matches])
+        _, rvec, t, inliers = cv.solvePnPRansac(target_pts, src_pts, self.calibration, None)
+        self.rotation, _ = cv.Rodrigues(rvec)
+        self.position = - np.transpose(self.rotation) @ t.flatten()
+
+    def refine_camera(self, pointMatches):
+        """
+        Once that there is a minimal set of initial camera parameters (calibration, rotation and position roughly known),
+        this method can be used to refine the solution using a non-linear optimization procedure.
+        :param pointMatches:  A list of pairs of 3D-2D point matches .
+
+        """
+        rvec, _ = cv.Rodrigues(self.rotation)
+        target_pts = np.array([pt[0] for pt in pointMatches])
+        src_pts = np.array([pt[1] for pt in pointMatches])
+
+        rvec, t = cv.solvePnPRefineLM(target_pts, src_pts, self.calibration, None, rvec, -self.rotation @ self.position,
+                                      (cv.TERM_CRITERIA_MAX_ITER + cv.TERM_CRITERIA_EPS, 20000, 0.00001))
+        self.rotation, _ = cv.Rodrigues(rvec)
+        self.position = - np.transpose(self.rotation) @ t
+
+    def from_homography(self, homography):
+        """
+        This method initializes the essential camera parameters from the homography between the world plane of the pitch
+        and the image. It is based on the extraction of the calibration matrix from the homography (Algorithm 8.2 of
+        Multiple View Geometry in computer vision, p225), then using the relation between the camera parameters and the
+        same homography, we extract rough rotation and position estimates (Example 8.1 of Multiple View Geometry in
+        computer vision, p196).
+        :param homography: The homography that captures the transformation between the 3D flat model of the soccer pitch
+         and its image.
+        """
+        success, _ = self.estimate_calibration_matrix_from_plane_homography(homography)
+        if not success:
+            return False
+
+        hprim = np.linalg.inv(self.calibration) @ homography
+        lambda1 = 1 / np.linalg.norm(hprim[:, 0])
+        lambda2 = 1 / np.linalg.norm(hprim[:, 1])
+        lambda3 = np.sqrt(lambda1 * lambda2)
+
+        r0 = hprim[:, 0] * lambda1
+        r1 = hprim[:, 1] * lambda2
+        r2 = np.cross(r0, r1)
+
+        R = np.column_stack((r0, r1, r2))
+        u, s, vh = np.linalg.svd(R)
+        R = u @ vh
+        if np.linalg.det(R) < 0:
+            u[:, 2] *= -1
+            R = u @ vh
+        self.rotation = R
+        t = hprim[:, 2] * lambda3
+        self.position = - np.transpose(R) @ t
+        return True
+
+    def to_json_parameters(self):
+        """
+        Saves camera to a JSON serializable dictionary.
+        :return: The dictionary
+        """
+        pan, tilt, roll = rotation_matrix_to_pan_tilt_roll(self.rotation)
+        camera_dict = {
+            "pan_degrees": pan * 180. / np.pi,
+            "tilt_degrees": tilt * 180. / np.pi,
+            "roll_degrees": roll * 180. / np.pi,
+            "position_meters": self.position.tolist(),
+            "x_focal_length": self.xfocal_length,
+            "y_focal_length": self.yfocal_length,
+            "principal_point": [self.principal_point[0], self.principal_point[1]],
+            "radial_distortion": self.radial_distortion.tolist(),
+            "tangential_distortion": self.tangential_disto.tolist(),
+            "thin_prism_distortion": self.thin_prism_disto.tolist()
+
+        }
+        return camera_dict
+
+    def from_json_parameters(self, calib_json_object):
+        """
+        Loads camera parameters from dictionary.
+        :param calib_json_object: the dictionary containing camera parameters.
+        """
+        self.principal_point = calib_json_object["principal_point"]
+        self.image_width = 2 * self.principal_point[0]
+        self.image_height = 2 * self.principal_point[1]
+        self.xfocal_length = calib_json_object["x_focal_length"]
+        self.yfocal_length = calib_json_object["y_focal_length"]
+
+        self.calibration = np.array([
+            [self.xfocal_length, 0, self.principal_point[0]],
+            [0, self.yfocal_length, self.principal_point[1]],
+            [0, 0, 1]
+        ], dtype='float')
+
+        pan = calib_json_object['pan_degrees'] * np.pi / 180.
+        tilt = calib_json_object['tilt_degrees'] * np.pi / 180.
+        roll = calib_json_object['roll_degrees'] * np.pi / 180.
+
+        self.rotation = np.array([
+            [-np.sin(pan) * np.sin(roll) * np.cos(tilt) + np.cos(pan) * np.cos(roll),
+             np.sin(pan) * np.cos(roll) + np.sin(roll) * np.cos(pan) * np.cos(tilt), np.sin(roll) * np.sin(tilt)],
+            [-np.sin(pan) * np.cos(roll) * np.cos(tilt) - np.sin(roll) * np.cos(pan),
+             -np.sin(pan) * np.sin(roll) + np.cos(pan) * np.cos(roll) * np.cos(tilt), np.sin(tilt) * np.cos(roll)],
+            [np.sin(pan) * np.sin(tilt), -np.sin(tilt) * np.cos(pan), np.cos(tilt)]
+        ], dtype='float')
+
+        self.rotation = np.transpose(pan_tilt_roll_to_orientation(pan, tilt, roll))
+
+        self.position = np.array(calib_json_object['position_meters'], dtype='float')
+
+        self.radial_distortion = np.array(calib_json_object['radial_distortion'], dtype='float')
+        self.tangential_disto = np.array(calib_json_object['tangential_distortion'], dtype='float')
+        self.thin_prism_disto = np.array(calib_json_object['thin_prism_distortion'], dtype='float')
+
+    def distort(self, point):
+        """
+        Given a point in the normalized image plane, apply distortion
+        :param point: 2D point on the normalized image plane
+        :return: 2D distorted point
+        """
+        numerator = 1
+        denominator = 1
+        radius = np.sqrt(point[0] * point[0] + point[1] * point[1])
+
+        for i in range(3):
+            k = self.radial_distortion[i]
+            numerator += k * radius ** (2 * (i + 1))
+            k2n = self.radial_distortion[i + 3]
+            denominator += k2n * radius ** (2 * (i + 1))
+
+        radial_distortion_factor = numerator / denominator
+        xpp = point[0] * radial_distortion_factor + \
+              2 * self.tangential_disto[0] * point[0] * point[1] + self.tangential_disto[1] * (
+                      radius ** 2 + 2 * point[0] ** 2) + \
+              self.thin_prism_disto[0] * radius ** 2 + self.thin_prism_disto[1] * radius ** 4
+        ypp = point[1] * radial_distortion_factor + \
+              2 * self.tangential_disto[1] * point[0] * point[1] + self.tangential_disto[0] * (
+                      radius ** 2 + 2 * point[1] ** 2) + \
+              self.thin_prism_disto[2] * radius ** 2 + self.thin_prism_disto[3] * radius ** 4
+        return np.array([xpp, ypp], dtype=np.float32)
+
+    def project_point(self, point3D, distort=True):
+        """
+        Uses current camera parameters to predict where a 3D point is seen by the camera.
+        :param point3D: The 3D point in world coordinates.
+        :param distort: optional parameter to allow projection without distortion.
+        :return: The 2D coordinates of the imaged point
+        """
+        point = point3D - self.position
+        rotated_point = self.rotation @ np.transpose(point)
+        if rotated_point[2] <= 1e-3 :
+            return np.zeros(3)
+        rotated_point = rotated_point / rotated_point[2]
+        if distort:
+            distorted_point = self.distort(rotated_point)
+        else:
+            distorted_point = rotated_point
+        x = distorted_point[0] * self.xfocal_length + self.principal_point[0]
+        y = distorted_point[1] * self.yfocal_length + self.principal_point[1]
+        return np.array([x, y, 1])
+
+    def scale_resolution(self, factor):
+        """
+        Adapts the internal parameters for image resolution changes
+        :param factor: scaling factor
+        """
+        self.xfocal_length = self.xfocal_length * factor
+        self.yfocal_length = self.yfocal_length * factor
+        self.image_width = self.image_width * factor
+        self.image_height = self.image_height * factor
+
+        self.principal_point = (self.image_width / 2, self.image_height / 2)
+
+        self.calibration = np.array([
+            [self.xfocal_length, 0, self.principal_point[0]],
+            [0, self.yfocal_length, self.principal_point[1]],
+            [0, 0, 1]
+        ], dtype='float')
+
+    def draw_corners(self, image, color=(0, 255, 0)):
+        """
+        Draw the corners of a standard soccer pitch in the image.
+        :param image: cv image
+        :param color
+        :return: the image mat modified.
+        """
+        field = SoccerPitch()
+        for pt3D in field.point_dict.values():
+            projected = self.project_point(pt3D)
+            if projected[2] == 0.:
+                continue
+            projected /= projected[2]
+            if 0 < projected[0] < self.image_width and 0 < projected[1] < self.image_height:
+                cv.circle(image, (int(projected[0]), int(projected[1])), 3, color, 2)
+        return image
+
+    def draw_pitch(self, image, color=(0, 255, 0)):
+        """
+        Draws all the lines of the pitch on the image.
+        :param image
+        :param color
+        :return: modified image
+        """
+        field = SoccerPitch()
+
+        polylines = field.sample_field_points()
+        for line in polylines.values():
+            prev_point = self.project_point(line[0])
+            for point in line[1:]:
+                projected = self.project_point(point)
+                if projected[2] == 0.:
+                    continue
+                projected /= projected[2]
+                if 0 < projected[0] < self.image_width and 0 < projected[1] < self.image_height:
+                    cv.line(image, (int(prev_point[0]), int(prev_point[1])), (int(projected[0]), int(projected[1])),
+                            color, 1)
+                prev_point = projected
+        return image
+
+    def draw_colorful_pitch(self, image, palette):
+        """
+        Draws all the lines of the pitch on the image, each line color is specified by the palette argument.
+
+        :param image:
+        :param palette: dictionary associating line classes names with their BGR color.
+        :return: modified image
+        """
+        field = SoccerPitch()
+
+        polylines = field.sample_field_points()
+        for key, line in polylines.items():
+            if key not in palette.keys():
+                print(f"Can't draw {key}")
+                continue
+            prev_point = self.project_point(line[0])
+            for point in line[1:]:
+                projected = self.project_point(point)
+                if projected[2] == 0.:
+                    continue
+                projected /= projected[2]
+                if 0 < projected[0] < self.image_width and 0 < projected[1] < self.image_height:
+                    # BGR color
+                    cv.line(image, (int(prev_point[0]), int(prev_point[1])), (int(projected[0]), int(projected[1])),
+                            palette[key][::-1], 1)
+                prev_point = projected
+        return image
+
+    def estimate_calibration_matrix_from_plane_homography(self, homography):
+        """
+        This method initializes the calibration matrix from the homography between the world plane of the pitch
+        and the image. It is based on the extraction of the calibration matrix from the homography (Algorithm 8.2 of
+        Multiple View Geometry in computer vision, p225). The extraction is sensitive to noise, which is why we keep the
+        principal point in the middle of the image rather than using the one extracted by this method.
+        :param homography: homography between the world plane of the pitch and the image
+        """
+        H = np.reshape(homography, (9,))
+        A = np.zeros((5, 6))
+        A[0, 1] = 1.
+        A[1, 0] = 1.
+        A[1, 2] = -1.
+        A[2, 3] = self.principal_point[1] / self.principal_point[0]
+        A[2, 4] = -1.0
+        A[3, 0] = H[0] * H[1]
+        A[3, 1] = H[0] * H[4] + H[1] * H[3]
+        A[3, 2] = H[3] * H[4]
+        A[3, 3] = H[0] * H[7] + H[1] * H[6]
+        A[3, 4] = H[3] * H[7] + H[4] * H[6]
+        A[3, 5] = H[6] * H[7]
+        A[4, 0] = H[0] * H[0] - H[1] * H[1]
+        A[4, 1] = 2 * H[0] * H[3] - 2 * H[1] * H[4]
+        A[4, 2] = H[3] * H[3] - H[4] * H[4]
+        A[4, 3] = 2 * H[0] * H[6] - 2 * H[1] * H[7]
+        A[4, 4] = 2 * H[3] * H[6] - 2 * H[4] * H[7]
+        A[4, 5] = H[6] * H[6] - H[7] * H[7]
+
+        u, s, vh = np.linalg.svd(A)
+        w = vh[-1]
+        W = np.zeros((3, 3))
+        W[0, 0] = w[0] / w[5]
+        W[0, 1] = w[1] / w[5]
+        W[0, 2] = w[3] / w[5]
+        W[1, 0] = w[1] / w[5]
+        W[1, 1] = w[2] / w[5]
+        W[1, 2] = w[4] / w[5]
+        W[2, 0] = w[3] / w[5]
+        W[2, 1] = w[4] / w[5]
+        W[2, 2] = w[5] / w[5]
+
+        try:
+            Ktinv = np.linalg.cholesky(W)
+        except np.linalg.LinAlgError:
+            K = np.eye(3)
+            return False, K
+
+        K = np.linalg.inv(np.transpose(Ktinv))
+        K /= K[2, 2]
+
+        self.xfocal_length = K[0, 0]
+        self.yfocal_length = K[1, 1]
+        # the principal point estimated by this method is very noisy, better keep it in the center of the image
+        self.principal_point = (self.image_width / 2, self.image_height / 2)
+        # self.principal_point = (K[0,2], K[1,2])
+        self.calibration = np.array([
+            [self.xfocal_length, 0, self.principal_point[0]],
+            [0, self.yfocal_length, self.principal_point[1]],
+            [0, 0, 1]
+        ], dtype='float')
+        return True, K
+

sn_calibration/src/dataloader.py

@@ -0,0 +1,122 @@
+"""
+DataLoader used to train the segmentation network used for the prediction of extremities.
+"""
+
+import json
+import os
+import time
+from argparse import ArgumentParser
+
+import cv2 as cv
+import numpy as np
+from torch.utils.data import Dataset
+from tqdm import tqdm
+
+from src.soccerpitch import SoccerPitch
+
+
+class SoccerNetDataset(Dataset):
+    def __init__(self,
+                 datasetpath,
+                 split="test",
+                 width=640,
+                 height=360,
+                 mean="../resources/mean.npy",
+                 std="../resources/std.npy"):
+        self.mean = np.load(mean)
+        self.std = np.load(std)
+        self.width = width
+        self.height = height
+
+        dataset_dir = os.path.join(datasetpath, split)
+        if not os.path.exists(dataset_dir):
+            print("Invalid dataset path !")
+            exit(-1)
+
+        frames = [f for f in os.listdir(dataset_dir) if ".jpg" in f]
+
+        self.data = []
+        self.n_samples = 0
+        for frame in frames:
+
+            frame_index = frame.split(".")[0]
+            annotation_file = os.path.join(dataset_dir, f"{frame_index}.json")
+            if not os.path.exists(annotation_file):
+                continue
+            with open(annotation_file, "r") as f:
+                groundtruth_lines = json.load(f)
+            img_path = os.path.join(dataset_dir, frame)
+            if groundtruth_lines:
+                self.data.append({
+                    "image_path": img_path,
+                    "annotations": groundtruth_lines,
+                })
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, index):
+        item = self.data[index]
+
+        img = cv.imread(item["image_path"])
+        img = cv.resize(img, (self.width, self.height), interpolation=cv.INTER_LINEAR)
+
+        mask = np.zeros(img.shape[:-1], dtype=np.uint8)
+        img = np.asarray(img, np.float32) / 255.
+        img -= self.mean
+        img /= self.std
+        img = img.transpose((2, 0, 1))
+        for class_number, class_ in enumerate(SoccerPitch.lines_classes):
+            if class_ in item["annotations"].keys():
+                key = class_
+                line = item["annotations"][key]
+                prev_point = line[0]
+                for i in range(1, len(line)):
+                    next_point = line[i]
+                    cv.line(mask,
+                            (int(prev_point["x"] * mask.shape[1]), int(prev_point["y"] * mask.shape[0])),
+                            (int(next_point["x"] * mask.shape[1]), int(next_point["y"] * mask.shape[0])),
+                            class_number + 1,
+                            2)
+                    prev_point = next_point
+        return img, mask
+
+
+if __name__ == "__main__":
+
+    # Load the arguments
+    parser = ArgumentParser(description='dataloader')
+
+    parser.add_argument('--SoccerNet_path', default="./annotations/", type=str,
+                        help='Path to the SoccerNet-V3 dataset folder')
+    parser.add_argument('--tiny', required=False, type=int, default=None, help='Select a subset of x games')
+    parser.add_argument('--split', required=False, type=str, default="test", help='Select the split of data')
+    parser.add_argument('--num_workers', required=False, type=int, default=4,
+                        help='number of workers for the dataloader')
+    parser.add_argument('--resolution_width', required=False, type=int, default=1920,
+                        help='width resolution of the images')
+    parser.add_argument('--resolution_height', required=False, type=int, default=1080,
+                        help='height resolution of the images')
+    parser.add_argument('--preload_images', action='store_true',
+                        help="Preload the images when constructing the dataset")
+    parser.add_argument('--zipped_images', action='store_true', help="Read images from zipped folder")
+
+    args = parser.parse_args()
+
+    start_time = time.time()
+    soccernet = SoccerNetDataset(args.SoccerNet_path, split=args.split)
+    with tqdm(enumerate(soccernet), total=len(soccernet), ncols=160) as t:
+        for i, data in t:
+            img = soccernet[i][0].astype(np.uint8).transpose((1, 2, 0))
+            print(img.shape)
+            print(img.dtype)
+            cv.imshow("Normalized image", img)
+            cv.waitKey(0)
+            cv.destroyAllWindows()
+            print(data[1].shape)
+            cv.imshow("Mask", soccernet[i][1].astype(np.uint8))
+            cv.waitKey(0)
+            cv.destroyAllWindows()
+            continue
+    end_time = time.time()
+    print(end_time - start_time)

sn_calibration/src/detect_extremities.py

@@ -0,0 +1,314 @@
+import argparse
+import copy
+import json
+import os.path
+import random
+from collections import deque
+from pathlib import Path
+
+import cv2 as cv
+import numpy as np
+import torch
+import torch.backends.cudnn
+import torch.nn as nn
+from PIL import Image
+from torchvision.models.segmentation import deeplabv3_resnet50
+from tqdm import tqdm
+
+from soccerpitch import SoccerPitch
+
+
+def generate_class_synthesis(semantic_mask, radius):
+    """
+    This function selects for each class present in the semantic mask, a set of circles that cover most of the semantic
+    class blobs.
+    :param semantic_mask: a image containing the segmentation predictions
+    :param radius: circle radius
+    :return: a dictionary which associates with each class detected a list of points ( the circles centers)
+    """
+    buckets = dict()
+    kernel = np.ones((5, 5), np.uint8)
+    semantic_mask = cv.erode(semantic_mask, kernel, iterations=1)
+    for k, class_name in enumerate(SoccerPitch.lines_classes):
+        mask = semantic_mask == k + 1
+        if mask.sum() > 0:
+            disk_list = synthesize_mask(mask, radius)
+            if len(disk_list):
+                buckets[class_name] = disk_list
+
+    return buckets
+
+
+def join_points(point_list, maxdist):
+    """
+    Given a list of points that were extracted from the blobs belonging to a same semantic class, this function creates
+    polylines by linking close points together if their distance is below the maxdist threshold.
+    :param point_list: List of points of the same line class
+    :param maxdist: minimal distance between two polylines.
+    :return: a list of polylines
+    """
+    polylines = []
+
+    if not len(point_list):
+        return polylines
+    head = point_list[0]
+    tail = point_list[0]
+    polyline = deque()
+    polyline.append(point_list[0])
+    remaining_points = copy.deepcopy(point_list[1:])
+
+    while len(remaining_points) > 0:
+        min_dist_tail = 1000
+        min_dist_head = 1000
+        best_head = -1
+        best_tail = -1
+        for j, point in enumerate(remaining_points):
+            dist_tail = np.sqrt(np.sum(np.square(point - tail)))
+            dist_head = np.sqrt(np.sum(np.square(point - head)))
+            if dist_tail < min_dist_tail:
+                min_dist_tail = dist_tail
+                best_tail = j
+            if dist_head < min_dist_head:
+                min_dist_head = dist_head
+                best_head = j
+
+        if min_dist_head <= min_dist_tail and min_dist_head < maxdist:
+            polyline.appendleft(remaining_points[best_head])
+            head = polyline[0]
+            remaining_points.pop(best_head)
+        elif min_dist_tail < min_dist_head and min_dist_tail < maxdist:
+            polyline.append(remaining_points[best_tail])
+            tail = polyline[-1]
+            remaining_points.pop(best_tail)
+        else:
+            polylines.append(list(polyline.copy()))
+            head = remaining_points[0]
+            tail = remaining_points[0]
+            polyline = deque()
+            polyline.append(head)
+            remaining_points.pop(0)
+    polylines.append(list(polyline))
+    return polylines
+
+
+def get_line_extremities(buckets, maxdist, width, height):
+    """
+    Given the dictionary {lines_class: points}, finds plausible extremities of each line, i.e the extremities
+    of the longest polyline that can be built on the class blobs,  and normalize its coordinates
+    by the image size.
+    :param buckets: The dictionary associating line classes to the set of circle centers that covers best the class
+    prediction blobs in the segmentation mask
+    :param maxdist: the maximal distance between two circle centers belonging to the same blob (heuristic)
+    :param width: image width
+    :param height: image height
+    :return: a dictionary associating to each class its extremities
+    """
+    extremities = dict()
+    for class_name, disks_list in buckets.items():
+        polyline_list = join_points(disks_list, maxdist)
+        max_len = 0
+        longest_polyline = []
+        for polyline in polyline_list:
+            if len(polyline) > max_len:
+                max_len = len(polyline)
+                longest_polyline = polyline
+        extremities[class_name] = [
+            {'x': longest_polyline[0][1] / width, 'y': longest_polyline[0][0] / height},
+            {'x': longest_polyline[-1][1] / width, 'y': longest_polyline[-1][0] / height}
+        ]
+    return extremities
+
+
+def get_support_center(mask, start, disk_radius, min_support=0.1):
+    """
+    Returns the barycenter of the True pixels under the area of the mask delimited by the circle of center start and
+    radius of disk_radius pixels.
+    :param mask: Boolean mask
+    :param start: A point located on a true pixel of the mask
+    :param disk_radius: the radius of the circles
+    :param min_support: proportion of the area under the circle area that should be True in order to get enough support
+    :return: A boolean indicating if there is enough support in the circle area, the barycenter of the True pixels under
+     the circle
+    """
+    x = int(start[0])
+    y = int(start[1])
+    support_pixels = 1
+    result = [x, y]
+    xstart = x - disk_radius
+    if xstart < 0:
+        xstart = 0
+    xend = x + disk_radius
+    if xend > mask.shape[0]:
+        xend = mask.shape[0] - 1
+
+    ystart = y - disk_radius
+    if ystart < 0:
+        ystart = 0
+    yend = y + disk_radius
+    if yend > mask.shape[1]:
+        yend = mask.shape[1] - 1
+
+    for i in range(xstart, xend + 1):
+        for j in range(ystart, yend + 1):
+            dist = np.sqrt(np.square(x - i) + np.square(y - j))
+            if dist < disk_radius and mask[i, j] > 0:
+                support_pixels += 1
+                result[0] += i
+                result[1] += j
+    support = True
+    if support_pixels < min_support * np.square(disk_radius) * np.pi:
+        support = False
+
+    result = np.array(result)
+    result = np.true_divide(result, support_pixels)
+
+    return support, result
+
+
+def synthesize_mask(semantic_mask, disk_radius):
+    """
+    Fits circles on the True pixels of the mask and returns those which have enough support : meaning that the
+    proportion of the area of the circle covering True pixels is higher that a certain threshold in order to avoid
+    fitting circles on alone pixels.
+    :param semantic_mask: boolean mask
+    :param disk_radius: radius of the circles
+    :return: a list of disk centers, that have enough support
+    """
+    mask = semantic_mask.copy().astype(np.uint8)
+    points = np.transpose(np.nonzero(mask))
+    disks = []
+    while len(points):
+
+        start = random.choice(points)
+        dist = 10.
+        success = True
+        while dist > 1.:
+            enough_support, center = get_support_center(mask, start, disk_radius)
+            if not enough_support:
+                bad_point = np.round(center).astype(np.int32)
+                cv.circle(mask, (bad_point[1], bad_point[0]), disk_radius, (0), -1)
+                success = False
+            dist = np.sqrt(np.sum(np.square(center - start)))
+            start = center
+        if success:
+            disks.append(np.round(start).astype(np.int32))
+            cv.circle(mask, (disks[-1][1], disks[-1][0]), disk_radius, 0, -1)
+        points = np.transpose(np.nonzero(mask))
+
+    return disks
+
+
+class SegmentationNetwork:
+    def __init__(self, model_file, mean_file, std_file, num_classes=29, width=640, height=360):
+        file_path = Path(model_file).resolve()
+        model = nn.DataParallel(deeplabv3_resnet50(pretrained=False, num_classes=num_classes))
+        self.init_weight(model, nn.init.kaiming_normal_,
+                         nn.BatchNorm2d, 1e-3, 0.1,
+                         mode='fan_in')
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        checkpoint = torch.load(str(file_path), map_location=self.device)
+        model.load_state_dict(checkpoint["model"])
+        model.eval()
+        self.model = model.to(self.device)
+        file_path = Path(mean_file).resolve()
+        self.mean = np.load(str(file_path))
+        file_path = Path(std_file).resolve()
+        self.std = np.load(str(file_path))
+        self.width = width
+        self.height = height
+
+    def init_weight(self, feature, conv_init, norm_layer, bn_eps, bn_momentum,
+                    **kwargs):
+        for name, m in feature.named_modules():
+            if isinstance(m, (nn.Conv2d, nn.Conv3d)):
+                conv_init(m.weight, **kwargs)
+            elif isinstance(m, norm_layer):
+                m.eps = bn_eps
+                m.momentum = bn_momentum
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+    def analyse_image(self, image):
+        """
+        Process image and perform inference, returns mask of detected classes
+        :param image: BGR image
+        :return: predicted classes mask
+        """
+        img = cv.resize(image, (self.width, self.height), interpolation=cv.INTER_LINEAR)
+        img = np.asarray(img, np.float32) / 255.
+        img = (img - self.mean) / self.std
+        img = img.transpose((2, 0, 1))
+        img = torch.from_numpy(img).to(self.device).unsqueeze(0)
+
+        cuda_result = self.model.forward(img.float())
+        output = cuda_result['out'].data[0].cpu().numpy()
+        output = output.transpose(1, 2, 0)
+        output = np.asarray(np.argmax(output, axis=2), dtype=np.uint8)
+
+        return output
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Test')
+
+    parser.add_argument('-s', '--soccernet', default="/home/fmg/data/SN23/calibration-2023-bis/", type=str,
+                        help='Path to the SoccerNet-V3 dataset folder')
+    parser.add_argument('-p', '--prediction', default="/home/fmg/results/SN23-tests/", required=False, type=str,
+                        help="Path to the prediction folder")
+    parser.add_argument('--split', required=False, type=str, default="challenge", help='Select the split of data')
+    parser.add_argument('--masks', required=False, type=bool, default=False, help='Save masks in prediction directory')
+    parser.add_argument('--resolution_width', required=False, type=int, default=640,
+                        help='width resolution of the images')
+    parser.add_argument('--resolution_height', required=False, type=int, default=360,
+                        help='height resolution of the images')
+    args = parser.parse_args()
+
+    lines_palette = [0, 0, 0]
+    for line_class in SoccerPitch.lines_classes:
+        lines_palette.extend(SoccerPitch.palette[line_class])
+
+    calib_net = SegmentationNetwork(
+        "../resources/soccer_pitch_segmentation.pth",
+        "../resources/mean.npy",
+        "../resources/std.npy")
+
+    dataset_dir = os.path.join(args.soccernet, args.split)
+    if not os.path.exists(dataset_dir):
+        print("Invalid dataset path !")
+        exit(-1)
+
+    with open(os.path.join(dataset_dir, "per_match_info.json"), 'r') as f:
+        match_info = json.load(f)
+
+    with tqdm(enumerate(match_info.keys()), total=len(match_info.keys()), ncols=160) as t:
+        for i, match in t:
+            frame_list = match_info[match].keys()
+
+            for frame in frame_list:
+
+                output_prediction_folder = os.path.join(args.prediction, args.split)
+                if not os.path.exists(output_prediction_folder):
+                    os.makedirs(output_prediction_folder)
+                prediction = dict()
+                count = 0
+
+                frame_path = os.path.join(dataset_dir, frame)
+
+                frame_index = frame.split(".")[0]
+
+                image = cv.imread(frame_path)
+                semlines = calib_net.analyse_image(image)
+                if args.masks:
+                    mask = Image.fromarray(semlines.astype(np.uint8)).convert('P')
+                    mask.putpalette(lines_palette)
+                    mask_file = os.path.join(output_prediction_folder, frame)
+                    mask.save(mask_file)
+                skeletons = generate_class_synthesis(semlines, 6)
+                extremities = get_line_extremities(skeletons, 40, args.resolution_width, args.resolution_height)
+
+                prediction = extremities
+                count += 1
+
+                prediction_file = os.path.join(output_prediction_folder, f"extremities_{frame_index}.json")
+                with open(prediction_file, "w") as f:
+                    json.dump(prediction, f, indent=4)

sn_calibration/src/evalai_camera.py

@@ -0,0 +1,133 @@
+import numpy as np
+import zipfile
+import argparse
+import json
+import sys
+
+from tqdm import tqdm
+
+sys.path.append("sn_calibration")
+sys.path.append("sn_calibration/src")
+
+from evaluate_camera import get_polylines, scale_points, evaluate_camera_prediction
+from evaluate_extremities import mirror_labels
+
+
+
+def evaluate(gt_zip, prediction_zip, width=960, height=540):
+    gt_archive = zipfile.ZipFile(gt_zip, 'r')
+    prediction_archive = zipfile.ZipFile(prediction_zip, 'r')
+    gt_jsons = gt_archive.namelist()
+
+    accuracies = []
+    precisions = []
+    recalls = []
+    dict_errors = {}
+    per_class_confusion_dict = {}
+    total_frames = 0
+    missed = 0
+    for gt_json in tqdm(gt_jsons):
+
+        #split, name = gt_json.split("/")
+        #pred_name = f"{split}/camera_{name}"
+        pred_name = f"camera_{gt_json}"
+
+        total_frames += 1
+
+        if pred_name not in prediction_archive.namelist():
+            missed += 1
+            continue
+
+        prediction = prediction_archive.read(pred_name)
+        prediction = json.loads(prediction.decode("utf-8"))
+        gt = gt_archive.read(gt_json)
+        gt = json.loads(gt.decode('utf-8'))
+
+        line_annotations = scale_points(gt, width, height)
+
+        img_groundtruth = line_annotations
+
+        img_prediction = get_polylines(prediction, width, height,
+                                       sampling_factor=0.9)
+
+        confusion1, per_class_conf1, reproj_errors1 = evaluate_camera_prediction(img_prediction,
+                                                                                 img_groundtruth,
+                                                                                5)
+
+        confusion2, per_class_conf2, reproj_errors2 = evaluate_camera_prediction(img_prediction,
+                                                                                 mirror_labels(img_groundtruth),
+                                                                             5)
+
+        accuracy1, accuracy2 = 0., 0.
+        if confusion1.sum() > 0:
+            accuracy1 = confusion1[0, 0] / confusion1.sum()
+
+        if confusion2.sum() > 0:
+            accuracy2 = confusion2[0, 0] / confusion2.sum()
+
+        if accuracy1 > accuracy2:
+            accuracy = accuracy1
+            confusion = confusion1
+            per_class_conf = per_class_conf1
+            reproj_errors = reproj_errors1
+        else:
+            accuracy = accuracy2
+            confusion = confusion2
+            per_class_conf = per_class_conf2
+            reproj_errors = reproj_errors2
+
+        accuracies.append(accuracy)
+        if confusion[0, :].sum() > 0:
+            precision = confusion[0, 0] / (confusion[0, :].sum())
+            precisions.append(precision)
+        if (confusion[0, 0] + confusion[1, 0]) > 0:
+            recall = confusion[0, 0] / (confusion[0, 0] + confusion[1, 0])
+            recalls.append(recall)
+
+        for line_class, errors in reproj_errors.items():
+            if line_class in dict_errors.keys():
+                dict_errors[line_class].extend(errors)
+            else:
+                dict_errors[line_class] = errors
+
+        for line_class, confusion_mat in per_class_conf.items():
+            if line_class in per_class_confusion_dict.keys():
+                per_class_confusion_dict[line_class] += confusion_mat
+            else:
+                per_class_confusion_dict[line_class] = confusion_mat
+
+
+    results = {}
+    results["completeness"] = (total_frames - missed) / total_frames
+    results["meanRecall"] = np.mean(recalls)
+    results["meanPrecision"] = np.mean(precisions)
+    results["meanAccuracies"] = np.mean(accuracies)
+    results["finalScore"] = results["completeness"] * results["meanAccuracies"]
+
+
+    for line_class, confusion_mat in per_class_confusion_dict.items():
+        class_accuracy = confusion_mat[0, 0] / confusion_mat.sum()
+        class_recall = confusion_mat[0, 0] / (confusion_mat[0, 0] + confusion_mat[1, 0])
+        class_precision = confusion_mat[0, 0] / (confusion_mat[0, 0] + confusion_mat[0, 1])
+        results[f"{line_class}Precision"] = class_precision
+        results[f"{line_class}Recall"] = class_recall
+        results[f"{line_class}Accuracy"] = class_accuracy
+    return results
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Evaluation camera calibration task')
+
+    parser.add_argument('-s', '--soccernet', default="/home/fmg/data/SN23/calibration-2023/test_secret.zip", type=str,
+                        help='Path to the zip groundtruth folder')
+    parser.add_argument('-p', '--prediction', default="/home/fmg/results/SN23-tests/test.zip",
+                        required=False, type=str,
+                        help="Path to the  zip prediction folder")
+    parser.add_argument('--width', type=int, default=960)
+    parser.add_argument('--height', type=int, default=540)
+
+    args = parser.parse_args()
+
+    results = evaluate(args.soccernet, args.prediction, args.width, args.height)
+    for key in results.keys():
+        print(f"{key}: {results[key]}")

sn_calibration/src/evaluate_camera.py

@@ -0,0 +1,365 @@
+import argparse
+import json
+import sys
+import os
+
+import matplotlib.pyplot as plt
+import numpy as np
+from tqdm import tqdm
+
+from camera import Camera
+from evaluate_extremities import scale_points, distance, mirror_labels
+from soccerpitch import SoccerPitch
+
+
+def get_polylines(camera_annotation, width, height, sampling_factor=0.2):
+    """
+    Given a set of camera parameters, this function adapts the camera to the desired image resolution and then
+    projects the 3D points belonging to the terrain model in order to give a dictionary associating the classes
+    observed and the points projected in the image.
+
+    :param camera_annotation: camera parameters in their json/dictionary format
+    :param width: image width for evaluation
+    :param height: image height for evaluation
+    :return: a dictionary with keys corresponding to a class observed in the image ( a line of the 3D model whose
+    projection falls in the image) and values are then the list of 2D projected points.
+    """
+
+    cam = Camera(width, height)
+    cam.from_json_parameters(camera_annotation)
+    field = SoccerPitch()
+    projections = dict()
+    sides = [
+        np.array([1, 0, 0]),
+        np.array([1, 0, -width + 1]),
+        np.array([0, 1, 0]),
+        np.array([0, 1, -height + 1])
+    ]
+    for key, points in field.sample_field_points(sampling_factor).items():
+        projections_list = []
+        in_img = False
+        prev_proj = np.zeros(3)
+        for i, point in enumerate(points):
+            ext = cam.project_point(point)
+            if ext[2] < 1e-5:
+                # point at infinity or behind camera
+                continue
+            if 0 <= ext[0] < width and 0 <= ext[1] < height:
+
+                if not in_img and i > 0:
+
+                    line = np.cross(ext, prev_proj)
+                    in_img_intersections = []
+                    dist_to_ext = []
+                    for side in sides:
+                        intersection = np.cross(line, side)
+                        intersection /= intersection[2]
+                        if 0 <= intersection[0] < width and 0 <= intersection[1] < height:
+                            in_img_intersections.append(intersection)
+                            dist_to_ext.append(np.sqrt(np.sum(np.square(intersection - ext))))
+                    if in_img_intersections:
+                        intersection = in_img_intersections[np.argmin(dist_to_ext)]
+
+                        projections_list.append(
+                            {
+                                "x": intersection[0],
+                                "y": intersection[1]
+                            }
+                        )
+
+                projections_list.append(
+                    {
+                        "x": ext[0],
+                        "y": ext[1]
+                    }
+                )
+                in_img = True
+            elif in_img:
+                # first point out
+                line = np.cross(ext, prev_proj)
+
+                in_img_intersections = []
+                dist_to_ext = []
+                for side in sides:
+                    intersection = np.cross(line, side)
+                    intersection /= intersection[2]
+                    if 0 <= intersection[0] < width and 0 <= intersection[1] < height:
+                        in_img_intersections.append(intersection)
+                        dist_to_ext.append(np.sqrt(np.sum(np.square(intersection - ext))))
+                if in_img_intersections:
+                    intersection = in_img_intersections[np.argmin(dist_to_ext)]
+
+                    projections_list.append(
+                        {
+                            "x": intersection[0],
+                            "y": intersection[1]
+                        }
+                    )
+                in_img = False
+            prev_proj = ext
+        if len(projections_list):
+            projections[key] = projections_list
+    return projections
+
+
+def distance_to_polyline(point, polyline):
+    """
+    Computes euclidian distance between a point and a polyline.
+    :param point: 2D point
+    :param polyline: a list of 2D point
+    :return: the distance value
+    """
+    if 0 < len(polyline) < 2:
+        dist = distance(point, polyline[0])
+        return dist
+    else:
+        dist_to_segments = []
+        point_np = np.array([point["x"], point["y"], 1])
+
+        for i in range(len(polyline) - 1):
+            origin_segment = np.array([
+                polyline[i]["x"],
+                polyline[i]["y"],
+                1
+            ])
+            end_segment = np.array([
+                polyline[i + 1]["x"],
+                polyline[i + 1]["y"],
+                1
+            ])
+            line = np.cross(origin_segment, end_segment)
+            line /= np.sqrt(np.square(line[0]) + np.square(line[1]))
+
+            # project point on line l
+            projected = np.cross((np.cross(np.array([line[0], line[1], 0]), point_np)), line)
+            projected = projected / projected[2]
+
+            v1 = projected - origin_segment
+            v2 = end_segment - origin_segment
+            k = np.dot(v1, v2) / np.dot(v2, v2)
+            if 0 < k < 1:
+
+                segment_distance = np.sqrt(np.sum(np.square(projected - point_np)))
+            else:
+                d1 = distance(point, polyline[i])
+                d2 = distance(point, polyline[i + 1])
+                segment_distance = np.min([d1, d2])
+
+            dist_to_segments.append(segment_distance)
+        return np.min(dist_to_segments)
+
+
+def evaluate_camera_prediction(projected_lines, groundtruth_lines, threshold):
+    """
+    Computes confusion matrices for a level of precision specified by the threshold.
+    A groundtruth line is correctly classified if it lies at less than threshold pixels from a line of the prediction
+    of the same class.
+    Computes also the reprojection error of each groundtruth point : the reprojection error is the L2 distance between
+    the point and the projection of the line.
+    :param projected_lines: dictionary of detected lines classes as keys and associated predicted points as values
+    :param groundtruth_lines: dictionary of annotated lines classes as keys and associated annotated points as values
+    :param threshold: distance in pixels that distinguishes good matches from bad ones
+    :return: confusion matrix, per class confusion matrix & per class reprojection errors
+    """
+    global_confusion_mat = np.zeros((2, 2), dtype=np.float32)
+    per_class_confusion = {}
+    dict_errors = {}
+    detected_classes = set(projected_lines.keys())
+    groundtruth_classes = set(groundtruth_lines.keys())
+
+    false_positives_classes = detected_classes - groundtruth_classes
+    for false_positive_class in false_positives_classes:
+        # false_positives = len(projected_lines[false_positive_class])
+        if "Circle" not in false_positive_class:
+            # Count only extremities for lines, independently of soccer pitch sampling
+            false_positives = 2.
+        else:
+            false_positives = 9.
+        per_class_confusion[false_positive_class] = np.array([[0., false_positives], [0., 0.]])
+        global_confusion_mat[0, 1] += 1
+
+    false_negatives_classes = groundtruth_classes - detected_classes
+    for false_negatives_class in false_negatives_classes:
+        false_negatives = len(groundtruth_lines[false_negatives_class])
+        per_class_confusion[false_negatives_class] = np.array([[0., 0.], [false_negatives, 0.]])
+        global_confusion_mat[1, 0] += 1
+
+    common_classes = detected_classes - false_positives_classes
+
+    for detected_class in common_classes:
+
+        detected_points = projected_lines[detected_class]
+        groundtruth_points = groundtruth_lines[detected_class]
+
+        per_class_confusion[detected_class] = np.zeros((2, 2))
+
+        all_below_dist = 1
+        for point in groundtruth_points:
+
+            dist_to_poly = distance_to_polyline(point, detected_points)
+            if dist_to_poly < threshold:
+                per_class_confusion[detected_class][0, 0] += 1
+            else:
+                per_class_confusion[detected_class][0, 1] += 1
+                all_below_dist *= 0
+
+            if detected_class in dict_errors.keys():
+                dict_errors[detected_class].append(dist_to_poly)
+            else:
+                dict_errors[detected_class] = [dist_to_poly]
+
+        if all_below_dist:
+            global_confusion_mat[0, 0] += 1
+        else:
+            global_confusion_mat[0, 1] += 1
+
+    return global_confusion_mat, per_class_confusion, dict_errors
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser(description='Evaluation camera calibration task')
+
+    parser.add_argument('-s', '--soccernet', default="/home/fmg/data/SN23/calibration-2023-bis/", type=str,
+                        help='Path to the SoccerNet-V3 dataset folder')
+    parser.add_argument('-p', '--prediction', default="/home/fmg/results/SN23-tests/",
+                        required=False, type=str,
+                        help="Path to the prediction folder")
+    parser.add_argument('-t', '--threshold', default=5, required=False, type=int,
+                        help="Accuracy threshold in pixels")
+    parser.add_argument('--split', required=False, type=str, default="valid", help='Select the split of data')
+    parser.add_argument('--resolution_width', required=False, type=int, default=960,
+                        help='width resolution of the images')
+    parser.add_argument('--resolution_height', required=False, type=int, default=540,
+                        help='height resolution of the images')
+    args = parser.parse_args()
+
+    accuracies = []
+    precisions = []
+    recalls = []
+    dict_errors = {}
+    per_class_confusion_dict = {}
+
+    dataset_dir = os.path.join(args.soccernet, args.split)
+    if not os.path.exists(dataset_dir):
+        print("Invalid dataset path !")
+        exit(-1)
+
+    annotation_files = [f for f in os.listdir(dataset_dir) if ".json" in f]
+
+    missed, total_frames = 0, 0
+    with tqdm(enumerate(annotation_files), total=len(annotation_files), ncols=160) as t:
+        for i, annotation_file in t:
+            frame_index = annotation_file.split(".")[0]
+            annotation_file = os.path.join(args.soccernet, args.split, annotation_file)
+            prediction_file = os.path.join(args.prediction, args.split, f"camera_{frame_index}.json")
+
+            total_frames += 1
+
+            if not os.path.exists(prediction_file):
+                missed += 1
+
+                continue
+
+            with open(annotation_file, 'r') as f:
+                line_annotations = json.load(f)
+
+            with open(prediction_file, 'r') as f:
+                predictions = json.load(f)
+
+            line_annotations = scale_points(line_annotations, args.resolution_width, args.resolution_height)
+
+            image_path = os.path.join(args.soccernet, args.split, f"{frame_index}.jpg")
+
+            img_groundtruth = line_annotations
+
+            img_prediction = get_polylines(predictions, args.resolution_width, args.resolution_height,
+                                           sampling_factor=0.9)
+
+            confusion1, per_class_conf1, reproj_errors1 = evaluate_camera_prediction(img_prediction,
+                                                                                     img_groundtruth,
+                                                                                     args.threshold)
+
+            confusion2, per_class_conf2, reproj_errors2 = evaluate_camera_prediction(img_prediction,
+                                                                                     mirror_labels(img_groundtruth),
+                                                                                     args.threshold)
+
+            accuracy1, accuracy2 = 0., 0.
+            if confusion1.sum() > 0:
+                accuracy1 = confusion1[0, 0] / confusion1.sum()
+
+            if confusion2.sum() > 0:
+                accuracy2 = confusion2[0, 0] / confusion2.sum()
+
+            if accuracy1 > accuracy2:
+                accuracy = accuracy1
+                confusion = confusion1
+                per_class_conf = per_class_conf1
+                reproj_errors = reproj_errors1
+            else:
+                accuracy = accuracy2
+                confusion = confusion2
+                per_class_conf = per_class_conf2
+                reproj_errors = reproj_errors2
+
+            accuracies.append(accuracy)
+            if confusion[0, :].sum() > 0:
+                precision = confusion[0, 0] / (confusion[0, :].sum())
+                precisions.append(precision)
+            if (confusion[0, 0] + confusion[1, 0]) > 0:
+                recall = confusion[0, 0] / (confusion[0, 0] + confusion[1, 0])
+                recalls.append(recall)
+
+            for line_class, errors in reproj_errors.items():
+                if line_class in dict_errors.keys():
+                    dict_errors[line_class].extend(errors)
+                else:
+                    dict_errors[line_class] = errors
+
+            for line_class, confusion_mat in per_class_conf.items():
+                if line_class in per_class_confusion_dict.keys():
+                    per_class_confusion_dict[line_class] += confusion_mat
+                else:
+                    per_class_confusion_dict[line_class] = confusion_mat
+
+    completeness_score = (total_frames - missed) / total_frames
+    mAccuracy = np.mean(accuracies)
+
+    final_score = completeness_score * mAccuracy
+    print(f" On SoccerNet {args.split} set, final score of : {final_score}")
+    print(f" On SoccerNet {args.split} set, completeness rate of : {completeness_score}")
+
+    mRecall = np.mean(recalls)
+    sRecall = np.std(recalls)
+    medianRecall = np.median(recalls)
+    print(
+        f" On SoccerNet {args.split} set, recall mean value : {mRecall * 100:2.2f}% with standard deviation of {sRecall * 100:2.2f}% and median of {medianRecall * 100:2.2f}%")
+
+    mPrecision = np.mean(precisions)
+    sPrecision = np.std(precisions)
+    medianPrecision = np.median(precisions)
+    print(
+        f" On SoccerNet {args.split} set, precision mean value : {mPrecision * 100:2.2f}% with standard deviation of {sPrecision * 100:2.2f}% and median of {medianPrecision * 100:2.2f}%")
+
+    sAccuracy = np.std(accuracies)
+    medianAccuracy = np.median(accuracies)
+    print(
+        f" On SoccerNet {args.split} set, accuracy mean value :  {mAccuracy * 100:2.2f}% with standard deviation of {sAccuracy * 100:2.2f}% and median of {medianAccuracy * 100:2.2f}%")
+
+    print()
+
+    for line_class, confusion_mat in per_class_confusion_dict.items():
+        class_accuracy = confusion_mat[0, 0] / confusion_mat.sum()
+        class_recall = confusion_mat[0, 0] / (confusion_mat[0, 0] + confusion_mat[1, 0])
+        class_precision = confusion_mat[0, 0] / (confusion_mat[0, 0] + confusion_mat[0, 1])
+        print(
+            f"For class {line_class}, accuracy of {class_accuracy * 100:2.2f}%, precision of {class_precision * 100:2.2f}%  and recall of {class_recall * 100:2.2f}%")
+
+        for k, v in dict_errors.items():
+            fig, ax1 = plt.subplots(figsize=(11, 8))
+            ax1.hist(v, bins=30, range=(0, 60))
+            ax1.set_title(k)
+            ax1.set_xlabel("Errors in pixel")
+            os.makedirs(f"./results/", exist_ok=True)
+            plt.savefig(f"./results/{k}_reprojection_error.png")
+            plt.close(fig)

sn_calibration/src/evaluate_extremities.py

@@ -0,0 +1,274 @@
+import argparse
+import json
+import sys
+import os
+
+import matplotlib.pyplot as plt
+import numpy as np
+from tqdm import tqdm
+
+sys.path.append("sn_calibration")
+sys.path.append("sn_calibration/src")
+
+from soccerpitch import SoccerPitch
+
+
+def distance(point1, point2):
+    """
+    Computes euclidian distance between 2D points
+    :param point1
+    :param point2
+    :return: euclidian distance between point1 and point2
+    """
+    diff = np.array([point1['x'], point1['y']]) - np.array([point2['x'], point2['y']])
+    sq_dist = np.square(diff)
+    return np.sqrt(sq_dist.sum())
+
+
+def mirror_labels(lines_dict):
+    """
+    Replace each line class key of the dictionary with its opposite element according to a central projection by the
+    soccer pitch center
+    :param lines_dict: dictionary whose keys will be mirrored
+    :return: Dictionary with mirrored keys and same values
+    """
+    mirrored_dict = dict()
+    for line_class, value in lines_dict.items():
+        mirrored_dict[SoccerPitch.symetric_classes[line_class]] = value
+    return mirrored_dict
+
+
+def evaluate_detection_prediction(detected_lines, groundtruth_lines, threshold=2.):
+    """
+    Evaluates the prediction of extremities. The extremities associated to a class are unordered. The extremities of the
+    "Circle central" element is not well-defined for this task, thus this class is ignored.
+    Computes confusion matrices for a level of precision specified by the threshold.
+    A groundtruth extremity point is correctly classified if it lies at less than threshold pixels from the
+    corresponding extremity point of the prediction of the same class.
+    Computes also the euclidian distance between each predicted extremity and its closest groundtruth extremity, when
+    both the groundtruth and the prediction contain the element class.
+
+    :param detected_lines: dictionary of detected lines classes as keys and associated predicted extremities as values
+    :param groundtruth_lines: dictionary of annotated lines classes as keys and associated annotated points as values
+    :param threshold: distance in pixels that distinguishes good matches from bad ones
+    :return: confusion matrix, per class confusion matrix & per class localization errors
+    """
+    confusion_mat = np.zeros((2, 2), dtype=np.float32)
+    per_class_confusion = {}
+    errors_dict = {}
+    detected_classes = set(detected_lines.keys())
+    groundtruth_classes = set(groundtruth_lines.keys())
+
+    if "Circle central" in groundtruth_classes:
+        groundtruth_classes.remove("Circle central")
+    if "Circle central" in detected_classes:
+        detected_classes.remove("Circle central")
+
+    false_positives_classes = detected_classes - groundtruth_classes
+    for false_positive_class in false_positives_classes:
+        false_positives = len(detected_lines[false_positive_class])
+        confusion_mat[0, 1] += false_positives
+        per_class_confusion[false_positive_class] = np.array([[0., false_positives], [0., 0.]])
+
+    false_negatives_classes = groundtruth_classes - detected_classes
+    for false_negatives_class in false_negatives_classes:
+        false_negatives = len(groundtruth_lines[false_negatives_class])
+        confusion_mat[1, 0] += false_negatives
+        per_class_confusion[false_negatives_class] = np.array([[0., 0.], [false_negatives, 0.]])
+
+    common_classes = detected_classes - false_positives_classes
+
+    for detected_class in common_classes:
+
+        detected_points = detected_lines[detected_class]
+
+        groundtruth_points = groundtruth_lines[detected_class]
+
+        groundtruth_extremities = [groundtruth_points[0], groundtruth_points[-1]]
+        predicted_extremities = [detected_points[0], detected_points[-1]]
+        per_class_confusion[detected_class] = np.zeros((2, 2))
+
+        dist1 = distance(groundtruth_extremities[0], predicted_extremities[0])
+        dist1rev = distance(groundtruth_extremities[1], predicted_extremities[0])
+
+        dist2 = distance(groundtruth_extremities[1], predicted_extremities[1])
+        dist2rev = distance(groundtruth_extremities[0], predicted_extremities[1])
+        if dist1rev <= dist1 and dist2rev <= dist2:
+            # reverse order
+            dist1 = dist1rev
+            dist2 = dist2rev
+
+        errors_dict[detected_class] = [dist1, dist2]
+
+        if dist1 < threshold:
+            confusion_mat[0, 0] += 1
+            per_class_confusion[detected_class][0, 0] += 1
+        else:
+            # treat too far detections as false positives
+            confusion_mat[0, 1] += 1
+            per_class_confusion[detected_class][0, 1] += 1
+
+        if dist2 < threshold:
+            confusion_mat[0, 0] += 1
+            per_class_confusion[detected_class][0, 0] += 1
+
+        else:
+            # treat too far detections as false positives
+            confusion_mat[0, 1] += 1
+            per_class_confusion[detected_class][0, 1] += 1
+
+    return confusion_mat, per_class_confusion, errors_dict
+
+
+def scale_points(points_dict, s_width, s_height):
+    """
+    Scale points by s_width and s_height factors
+    :param points_dict: dictionary of annotations/predictions with normalized point values
+    :param s_width: width scaling factor
+    :param s_height: height scaling factor
+    :return: dictionary with scaled points
+    """
+    line_dict = {}
+    for line_class, points in points_dict.items():
+        scaled_points = []
+        for point in points:
+            new_point = {'x': point['x'] * (s_width-1), 'y': point['y'] * (s_height-1)}
+            scaled_points.append(new_point)
+        if len(scaled_points):
+            line_dict[line_class] = scaled_points
+    return line_dict
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser(description='Test')
+
+    parser.add_argument('-s', '--soccernet', default="./annotations", type=str,
+                        help='Path to the SoccerNet-V3 dataset folder')
+    parser.add_argument('-p', '--prediction', default="./results_bis",
+                        required=False, type=str,
+                        help="Path to the prediction folder")
+    parser.add_argument('-t', '--threshold', default=10, required=False, type=int,
+                        help="Accuracy threshold in pixels")
+    parser.add_argument('--split', required=False, type=str, default="test", help='Select the split of data')
+    parser.add_argument('--resolution_width', required=False, type=int, default=960,
+                        help='width resolution of the images')
+    parser.add_argument('--resolution_height', required=False, type=int, default=540,
+                        help='height resolution of the images')
+    args = parser.parse_args()
+
+    accuracies = []
+    precisions = []
+    recalls = []
+    dict_errors = {}
+    per_class_confusion_dict = {}
+
+    dataset_dir = os.path.join(args.soccernet, args.split)
+    if not os.path.exists(dataset_dir):
+        print("Invalid dataset path !")
+        exit(-1)
+
+    annotation_files = [f for f in os.listdir(dataset_dir) if ".json" in f]
+
+    with tqdm(enumerate(annotation_files), total=len(annotation_files), ncols=160) as t:
+        for i, annotation_file in t:
+            frame_index = annotation_file.split(".")[0]
+            annotation_file = os.path.join(args.soccernet, args.split, annotation_file)
+            prediction_file = os.path.join(args.prediction, args.split, f"extremities_{frame_index}.json")
+
+            if not os.path.exists(prediction_file):
+                accuracies.append(0.)
+                precisions.append(0.)
+                recalls.append(0.)
+                continue
+
+            with open(annotation_file, 'r') as f:
+                line_annotations = json.load(f)
+
+            with open(prediction_file, 'r') as f:
+                predictions = json.load(f)
+
+            predictions = scale_points(predictions, args.resolution_width, args.resolution_height)
+            line_annotations = scale_points(line_annotations, args.resolution_width, args.resolution_height)
+
+            img_prediction = predictions
+            img_groundtruth = line_annotations
+            confusion1, per_class_conf1, reproj_errors1 = evaluate_detection_prediction(img_prediction,
+                                                                                        img_groundtruth,
+                                                                                        args.threshold)
+            confusion2, per_class_conf2, reproj_errors2 = evaluate_detection_prediction(img_prediction,
+                                                                                        mirror_labels(
+                                                                                            img_groundtruth),
+                                                                                        args.threshold)
+
+            accuracy1, accuracy2 = 0., 0.
+            if confusion1.sum() > 0:
+                accuracy1 = confusion1[0, 0] / confusion1.sum()
+
+            if confusion2.sum() > 0:
+                accuracy2 = confusion2[0, 0] / confusion2.sum()
+
+            if accuracy1 > accuracy2:
+                accuracy = accuracy1
+                confusion = confusion1
+                per_class_conf = per_class_conf1
+                reproj_errors = reproj_errors1
+            else:
+                accuracy = accuracy2
+                confusion = confusion2
+                per_class_conf = per_class_conf2
+                reproj_errors = reproj_errors2
+
+            accuracies.append(accuracy)
+            if confusion[0, :].sum() > 0:
+                precision = confusion[0, 0] / (confusion[0, :].sum())
+                precisions.append(precision)
+            if (confusion[0, 0] + confusion[1, 0]) > 0:
+                recall = confusion[0, 0] / (confusion[0, 0] + confusion[1, 0])
+                recalls.append(recall)
+
+            for line_class, errors in reproj_errors.items():
+                if line_class in dict_errors.keys():
+                    dict_errors[line_class].extend(errors)
+                else:
+                    dict_errors[line_class] = errors
+
+            for line_class, confusion_mat in per_class_conf.items():
+                if line_class in per_class_confusion_dict.keys():
+                    per_class_confusion_dict[line_class] += confusion_mat
+                else:
+                    per_class_confusion_dict[line_class] = confusion_mat
+
+    mRecall = np.mean(recalls)
+    sRecall = np.std(recalls)
+    medianRecall = np.median(recalls)
+    print(
+        f" On SoccerNet {args.split} set, recall mean value : {mRecall * 100:2.2f}% with standard deviation of {sRecall * 100:2.2f}% and median of {medianRecall * 100:2.2f}%")
+
+    mPrecision = np.mean(precisions)
+    sPrecision = np.std(precisions)
+    medianPrecision = np.median(precisions)
+    print(
+        f" On SoccerNet {args.split} set, precision mean value : {mPrecision * 100:2.2f}% with standard deviation of {sPrecision * 100:2.2f}% and median of {medianPrecision * 100:2.2f}%")
+
+    mAccuracy = np.mean(accuracies)
+    sAccuracy = np.std(accuracies)
+    medianAccuracy = np.median(accuracies)
+    print(
+        f" On SoccerNet {args.split} set, accuracy mean value : {mAccuracy * 100:2.2f}% with standard deviation of {sAccuracy * 100:2.2f}% and median of {medianAccuracy * 100:2.2f}%")
+
+    for line_class, confusion_mat in per_class_confusion_dict.items():
+        class_accuracy = confusion_mat[0, 0] / confusion_mat.sum()
+        class_recall = confusion_mat[0, 0] / (confusion_mat[0, 0] + confusion_mat[1, 0])
+        class_precision = confusion_mat[0, 0] / (confusion_mat[0, 0] + confusion_mat[0, 1])
+        print(
+            f"For class {line_class}, accuracy of {class_accuracy * 100:2.2f}%, precision of {class_precision * 100:2.2f}%  and recall of {class_recall * 100:2.2f}%")
+
+    for k, v in dict_errors.items():
+        fig, ax1 = plt.subplots(figsize=(11, 8))
+        ax1.hist(v, bins=30, range=(0, 60))
+        ax1.set_title(k)
+        ax1.set_xlabel("Errors in pixel")
+        os.makedirs(f"./results/", exist_ok=True)
+        plt.savefig(f"./results/{k}_detection_error.png")
+        plt.close(fig)

sn_calibration/src/soccerpitch.py

@@ -0,0 +1,528 @@
+import numpy as np
+
+
+class SoccerPitch:
+    """Static class variables that are specified by the rules of the game """
+    GOAL_LINE_TO_PENALTY_MARK = 11.0
+    PENALTY_AREA_WIDTH = 40.32
+    PENALTY_AREA_LENGTH = 16.5
+    GOAL_AREA_WIDTH = 18.32
+    GOAL_AREA_LENGTH = 5.5
+    CENTER_CIRCLE_RADIUS = 9.15
+    GOAL_HEIGHT = 2.44
+    GOAL_LENGTH = 7.32
+
+    lines_classes = [
+        'Big rect. left bottom',
+        'Big rect. left main',
+        'Big rect. left top',
+        'Big rect. right bottom',
+        'Big rect. right main',
+        'Big rect. right top',
+        'Circle central',
+        'Circle left',
+        'Circle right',
+        'Goal left crossbar',
+        'Goal left post left ',
+        'Goal left post right',
+        'Goal right crossbar',
+        'Goal right post left',
+        'Goal right post right',
+        'Goal unknown',
+        'Line unknown',
+        'Middle line',
+        'Side line bottom',
+        'Side line left',
+        'Side line right',
+        'Side line top',
+        'Small rect. left bottom',
+        'Small rect. left main',
+        'Small rect. left top',
+        'Small rect. right bottom',
+        'Small rect. right main',
+        'Small rect. right top'
+    ]
+
+    symetric_classes = {
+        'Side line top': 'Side line bottom',
+        'Side line bottom': 'Side line top',
+        'Side line left': 'Side line right',
+        'Middle line': 'Middle line',
+        'Side line right': 'Side line left',
+        'Big rect. left top': 'Big rect. right bottom',
+        'Big rect. left bottom': 'Big rect. right top',
+        'Big rect. left main': 'Big rect. right main',
+        'Big rect. right top': 'Big rect. left bottom',
+        'Big rect. right bottom': 'Big rect. left top',
+        'Big rect. right main': 'Big rect. left main',
+        'Small rect. left top': 'Small rect. right bottom',
+        'Small rect. left bottom': 'Small rect. right top',
+        'Small rect. left main': 'Small rect. right main',
+        'Small rect. right top': 'Small rect. left bottom',
+        'Small rect. right bottom': 'Small rect. left top',
+        'Small rect. right main': 'Small rect. left main',
+        'Circle left': 'Circle right',
+        'Circle central': 'Circle central',
+        'Circle right': 'Circle left',
+        'Goal left crossbar': 'Goal right crossbar',
+        'Goal left post left ': 'Goal right post left',
+        'Goal left post right': 'Goal right post right',
+        'Goal right crossbar': 'Goal left crossbar',
+        'Goal right post left': 'Goal left post left ',
+        'Goal right post right': 'Goal left post right',
+        'Goal unknown': 'Goal unknown',
+        'Line unknown': 'Line unknown'
+    }
+
+    # RGB values
+    palette = {
+        'Big rect. left bottom': (127, 0, 0),
+        'Big rect. left main': (102, 102, 102),
+        'Big rect. left top': (0, 0, 127),
+        'Big rect. right bottom': (86, 32, 39),
+        'Big rect. right main': (48, 77, 0),
+        'Big rect. right top': (14, 97, 100),
+        'Circle central': (0, 0, 255),
+        'Circle left': (255, 127, 0),
+        'Circle right': (0, 255, 255),
+        'Goal left crossbar': (255, 255, 200),
+        'Goal left post left ': (165, 255, 0),
+        'Goal left post right': (155, 119, 45),
+        'Goal right crossbar': (86, 32, 139),
+        'Goal right post left': (196, 120, 153),
+        'Goal right post right': (166, 36, 52),
+        'Goal unknown': (0, 0, 0),
+        'Line unknown': (0, 0, 0),
+        'Middle line': (255, 255, 0),
+        'Side line bottom': (255, 0, 255),
+        'Side line left': (0, 255, 150),
+        'Side line right': (0, 230, 0),
+        'Side line top': (230, 0, 0),
+        'Small rect. left bottom': (0, 150, 255),
+        'Small rect. left main': (254, 173, 225),
+        'Small rect. left top': (87, 72, 39),
+        'Small rect. right bottom': (122, 0, 255),
+        'Small rect. right main': (255, 255, 255),
+        'Small rect. right top': (153, 23, 153)
+    }
+
+    def __init__(self, pitch_length=105., pitch_width=68.):
+        """
+        Initialize 3D coordinates of all elements of the soccer pitch.
+        :param pitch_length: According to FIFA rules, length belong to [90,120] meters
+        :param pitch_width: According to FIFA rules, length belong to [45,90] meters
+        """
+        self.PITCH_LENGTH = pitch_length
+        self.PITCH_WIDTH = pitch_width
+
+        self.center_mark = np.array([0, 0, 0], dtype='float')
+        self.halfway_and_bottom_touch_line_mark = np.array([0, pitch_width / 2.0, 0], dtype='float')
+        self.halfway_and_top_touch_line_mark = np.array([0, -pitch_width / 2.0, 0], dtype='float')
+        self.halfway_line_and_center_circle_top_mark = np.array([0, -SoccerPitch.CENTER_CIRCLE_RADIUS, 0],
+                                                                dtype='float')
+        self.halfway_line_and_center_circle_bottom_mark = np.array([0, SoccerPitch.CENTER_CIRCLE_RADIUS, 0],
+                                                                   dtype='float')
+        self.bottom_right_corner = np.array([pitch_length / 2.0, pitch_width / 2.0, 0], dtype='float')
+        self.bottom_left_corner = np.array([-pitch_length / 2.0, pitch_width / 2.0, 0], dtype='float')
+        self.top_right_corner = np.array([pitch_length / 2.0, -pitch_width / 2.0, 0], dtype='float')
+        self.top_left_corner = np.array([-pitch_length / 2.0, -pitch_width / 2.0, 0], dtype='float')
+
+        self.left_goal_bottom_left_post = np.array([-pitch_length / 2.0, SoccerPitch.GOAL_LENGTH / 2., 0.],
+                                                   dtype='float')
+        self.left_goal_top_left_post = np.array(
+            [-pitch_length / 2.0, SoccerPitch.GOAL_LENGTH / 2., -SoccerPitch.GOAL_HEIGHT], dtype='float')
+        self.left_goal_bottom_right_post = np.array([-pitch_length / 2.0, -SoccerPitch.GOAL_LENGTH / 2., 0.],
+                                                    dtype='float')
+        self.left_goal_top_right_post = np.array(
+            [-pitch_length / 2.0, -SoccerPitch.GOAL_LENGTH / 2., -SoccerPitch.GOAL_HEIGHT], dtype='float')
+
+        self.right_goal_bottom_left_post = np.array([pitch_length / 2.0, -SoccerPitch.GOAL_LENGTH / 2., 0.],
+                                                    dtype='float')
+        self.right_goal_top_left_post = np.array(
+            [pitch_length / 2.0, -SoccerPitch.GOAL_LENGTH / 2., -SoccerPitch.GOAL_HEIGHT], dtype='float')
+        self.right_goal_bottom_right_post = np.array([pitch_length / 2.0, SoccerPitch.GOAL_LENGTH / 2., 0.],
+                                                     dtype='float')
+        self.right_goal_top_right_post = np.array(
+            [pitch_length / 2.0, SoccerPitch.GOAL_LENGTH / 2., -SoccerPitch.GOAL_HEIGHT], dtype='float')
+
+        self.left_penalty_mark = np.array([-pitch_length / 2.0 + SoccerPitch.GOAL_LINE_TO_PENALTY_MARK, 0, 0],
+                                          dtype='float')
+        self.right_penalty_mark = np.array([pitch_length / 2.0 - SoccerPitch.GOAL_LINE_TO_PENALTY_MARK, 0, 0],
+                                           dtype='float')
+
+        self.left_penalty_area_top_right_corner = np.array(
+            [-pitch_length / 2.0 + SoccerPitch.PENALTY_AREA_LENGTH, -SoccerPitch.PENALTY_AREA_WIDTH / 2.0, 0],
+            dtype='float')
+        self.left_penalty_area_top_left_corner = np.array(
+            [-pitch_length / 2.0, -SoccerPitch.PENALTY_AREA_WIDTH / 2.0, 0],
+            dtype='float')
+        self.left_penalty_area_bottom_right_corner = np.array(
+            [-pitch_length / 2.0 + SoccerPitch.PENALTY_AREA_LENGTH, SoccerPitch.PENALTY_AREA_WIDTH / 2.0, 0],
+            dtype='float')
+        self.left_penalty_area_bottom_left_corner = np.array(
+            [-pitch_length / 2.0, SoccerPitch.PENALTY_AREA_WIDTH / 2.0, 0],
+            dtype='float')
+        self.right_penalty_area_top_right_corner = np.array(
+            [pitch_length / 2.0, -SoccerPitch.PENALTY_AREA_WIDTH / 2.0, 0],
+            dtype='float')
+        self.right_penalty_area_top_left_corner = np.array(
+            [pitch_length / 2.0 - SoccerPitch.PENALTY_AREA_LENGTH, -SoccerPitch.PENALTY_AREA_WIDTH / 2.0, 0],
+            dtype='float')
+        self.right_penalty_area_bottom_right_corner = np.array(
+            [pitch_length / 2.0, SoccerPitch.PENALTY_AREA_WIDTH / 2.0, 0],
+            dtype='float')
+        self.right_penalty_area_bottom_left_corner = np.array(
+            [pitch_length / 2.0 - SoccerPitch.PENALTY_AREA_LENGTH, SoccerPitch.PENALTY_AREA_WIDTH / 2.0, 0],
+            dtype='float')
+
+        self.left_goal_area_top_right_corner = np.array(
+            [-pitch_length / 2.0 + SoccerPitch.GOAL_AREA_LENGTH, -SoccerPitch.GOAL_AREA_WIDTH / 2.0, 0], dtype='float')
+        self.left_goal_area_top_left_corner = np.array([-pitch_length / 2.0, - SoccerPitch.GOAL_AREA_WIDTH / 2.0, 0],
+                                                       dtype='float')
+        self.left_goal_area_bottom_right_corner = np.array(
+            [-pitch_length / 2.0 + SoccerPitch.GOAL_AREA_LENGTH, SoccerPitch.GOAL_AREA_WIDTH / 2.0, 0], dtype='float')
+        self.left_goal_area_bottom_left_corner = np.array([-pitch_length / 2.0, SoccerPitch.GOAL_AREA_WIDTH / 2.0, 0],
+                                                          dtype='float')
+        self.right_goal_area_top_right_corner = np.array([pitch_length / 2.0, -SoccerPitch.GOAL_AREA_WIDTH / 2.0, 0],
+                                                         dtype='float')
+        self.right_goal_area_top_left_corner = np.array(
+            [pitch_length / 2.0 - SoccerPitch.GOAL_AREA_LENGTH, -SoccerPitch.GOAL_AREA_WIDTH / 2.0, 0], dtype='float')
+        self.right_goal_area_bottom_right_corner = np.array([pitch_length / 2.0, SoccerPitch.GOAL_AREA_WIDTH / 2.0, 0],
+                                                            dtype='float')
+        self.right_goal_area_bottom_left_corner = np.array(
+            [pitch_length / 2.0 - SoccerPitch.GOAL_AREA_LENGTH, SoccerPitch.GOAL_AREA_WIDTH / 2.0, 0], dtype='float')
+
+        x = -pitch_length / 2.0 + SoccerPitch.PENALTY_AREA_LENGTH;
+        dx = SoccerPitch.PENALTY_AREA_LENGTH - SoccerPitch.GOAL_LINE_TO_PENALTY_MARK;
+        y = -np.sqrt(SoccerPitch.CENTER_CIRCLE_RADIUS * SoccerPitch.CENTER_CIRCLE_RADIUS - dx * dx);
+        self.top_left_16M_penalty_arc_mark = np.array([x, y, 0], dtype='float')
+
+        x = pitch_length / 2.0 - SoccerPitch.PENALTY_AREA_LENGTH;
+        dx = SoccerPitch.PENALTY_AREA_LENGTH - SoccerPitch.GOAL_LINE_TO_PENALTY_MARK;
+        y = -np.sqrt(SoccerPitch.CENTER_CIRCLE_RADIUS * SoccerPitch.CENTER_CIRCLE_RADIUS - dx * dx);
+        self.top_right_16M_penalty_arc_mark = np.array([x, y, 0], dtype='float')
+
+        x = -pitch_length / 2.0 + SoccerPitch.PENALTY_AREA_LENGTH;
+        dx = SoccerPitch.PENALTY_AREA_LENGTH - SoccerPitch.GOAL_LINE_TO_PENALTY_MARK;
+        y = np.sqrt(SoccerPitch.CENTER_CIRCLE_RADIUS * SoccerPitch.CENTER_CIRCLE_RADIUS - dx * dx);
+        self.bottom_left_16M_penalty_arc_mark = np.array([x, y, 0], dtype='float')
+
+        x = pitch_length / 2.0 - SoccerPitch.PENALTY_AREA_LENGTH;
+        dx = SoccerPitch.PENALTY_AREA_LENGTH - SoccerPitch.GOAL_LINE_TO_PENALTY_MARK;
+        y = np.sqrt(SoccerPitch.CENTER_CIRCLE_RADIUS * SoccerPitch.CENTER_CIRCLE_RADIUS - dx * dx);
+        self.bottom_right_16M_penalty_arc_mark = np.array([x, y, 0], dtype='float')
+
+        # self.set_elevations(elevation)
+
+        self.point_dict = {}
+        self.point_dict["CENTER_MARK"] = self.center_mark
+        self.point_dict["L_PENALTY_MARK"] = self.left_penalty_mark
+        self.point_dict["R_PENALTY_MARK"] = self.right_penalty_mark
+        self.point_dict["TL_PITCH_CORNER"] = self.top_left_corner
+        self.point_dict["BL_PITCH_CORNER"] = self.bottom_left_corner
+        self.point_dict["TR_PITCH_CORNER"] = self.top_right_corner
+        self.point_dict["BR_PITCH_CORNER"] = self.bottom_right_corner
+        self.point_dict["L_PENALTY_AREA_TL_CORNER"] = self.left_penalty_area_top_left_corner
+        self.point_dict["L_PENALTY_AREA_TR_CORNER"] = self.left_penalty_area_top_right_corner
+        self.point_dict["L_PENALTY_AREA_BL_CORNER"] = self.left_penalty_area_bottom_left_corner
+        self.point_dict["L_PENALTY_AREA_BR_CORNER"] = self.left_penalty_area_bottom_right_corner
+
+        self.point_dict["R_PENALTY_AREA_TL_CORNER"] = self.right_penalty_area_top_left_corner
+        self.point_dict["R_PENALTY_AREA_TR_CORNER"] = self.right_penalty_area_top_right_corner
+        self.point_dict["R_PENALTY_AREA_BL_CORNER"] = self.right_penalty_area_bottom_left_corner
+        self.point_dict["R_PENALTY_AREA_BR_CORNER"] = self.right_penalty_area_bottom_right_corner
+
+        self.point_dict["L_GOAL_AREA_TL_CORNER"] = self.left_goal_area_top_left_corner
+        self.point_dict["L_GOAL_AREA_TR_CORNER"] = self.left_goal_area_top_right_corner
+        self.point_dict["L_GOAL_AREA_BL_CORNER"] = self.left_goal_area_bottom_left_corner
+        self.point_dict["L_GOAL_AREA_BR_CORNER"] = self.left_goal_area_bottom_right_corner
+
+        self.point_dict["R_GOAL_AREA_TL_CORNER"] = self.right_goal_area_top_left_corner
+        self.point_dict["R_GOAL_AREA_TR_CORNER"] = self.right_goal_area_top_right_corner
+        self.point_dict["R_GOAL_AREA_BL_CORNER"] = self.right_goal_area_bottom_left_corner
+        self.point_dict["R_GOAL_AREA_BR_CORNER"] = self.right_goal_area_bottom_right_corner
+
+        self.point_dict["L_GOAL_TL_POST"] = self.left_goal_top_left_post
+        self.point_dict["L_GOAL_TR_POST"] = self.left_goal_top_right_post
+        self.point_dict["L_GOAL_BL_POST"] = self.left_goal_bottom_left_post
+        self.point_dict["L_GOAL_BR_POST"] = self.left_goal_bottom_right_post
+
+        self.point_dict["R_GOAL_TL_POST"] = self.right_goal_top_left_post
+        self.point_dict["R_GOAL_TR_POST"] = self.right_goal_top_right_post
+        self.point_dict["R_GOAL_BL_POST"] = self.right_goal_bottom_left_post
+        self.point_dict["R_GOAL_BR_POST"] = self.right_goal_bottom_right_post
+
+        self.point_dict["T_TOUCH_AND_HALFWAY_LINES_INTERSECTION"] = self.halfway_and_top_touch_line_mark
+        self.point_dict["B_TOUCH_AND_HALFWAY_LINES_INTERSECTION"] = self.halfway_and_bottom_touch_line_mark
+        self.point_dict["T_HALFWAY_LINE_AND_CENTER_CIRCLE_INTERSECTION"] = self.halfway_line_and_center_circle_top_mark
+        self.point_dict[
+            "B_HALFWAY_LINE_AND_CENTER_CIRCLE_INTERSECTION"] = self.halfway_line_and_center_circle_bottom_mark
+        self.point_dict["TL_16M_LINE_AND_PENALTY_ARC_INTERSECTION"] = self.top_left_16M_penalty_arc_mark
+        self.point_dict["BL_16M_LINE_AND_PENALTY_ARC_INTERSECTION"] = self.bottom_left_16M_penalty_arc_mark
+        self.point_dict["TR_16M_LINE_AND_PENALTY_ARC_INTERSECTION"] = self.top_right_16M_penalty_arc_mark
+        self.point_dict["BR_16M_LINE_AND_PENALTY_ARC_INTERSECTION"] = self.bottom_right_16M_penalty_arc_mark
+
+        self.line_extremities = dict()
+        self.line_extremities["Big rect. left bottom"] = (self.point_dict["L_PENALTY_AREA_BL_CORNER"],
+                                                          self.point_dict["L_PENALTY_AREA_BR_CORNER"])
+        self.line_extremities["Big rect. left top"] = (self.point_dict["L_PENALTY_AREA_TL_CORNER"],
+                                                       self.point_dict["L_PENALTY_AREA_TR_CORNER"])
+        self.line_extremities["Big rect. left main"] = (self.point_dict["L_PENALTY_AREA_TR_CORNER"],
+                                                        self.point_dict["L_PENALTY_AREA_BR_CORNER"])
+        self.line_extremities["Big rect. right bottom"] = (self.point_dict["R_PENALTY_AREA_BL_CORNER"],
+                                                           self.point_dict["R_PENALTY_AREA_BR_CORNER"])
+        self.line_extremities["Big rect. right top"] = (self.point_dict["R_PENALTY_AREA_TL_CORNER"],
+                                                        self.point_dict["R_PENALTY_AREA_TR_CORNER"])
+        self.line_extremities["Big rect. right main"] = (self.point_dict["R_PENALTY_AREA_TL_CORNER"],
+                                                         self.point_dict["R_PENALTY_AREA_BL_CORNER"])
+
+        self.line_extremities["Small rect. left bottom"] = (self.point_dict["L_GOAL_AREA_BL_CORNER"],
+                                                            self.point_dict["L_GOAL_AREA_BR_CORNER"])
+        self.line_extremities["Small rect. left top"] = (self.point_dict["L_GOAL_AREA_TL_CORNER"],
+                                                         self.point_dict["L_GOAL_AREA_TR_CORNER"])
+        self.line_extremities["Small rect. left main"] = (self.point_dict["L_GOAL_AREA_TR_CORNER"],
+                                                          self.point_dict["L_GOAL_AREA_BR_CORNER"])
+        self.line_extremities["Small rect. right bottom"] = (self.point_dict["R_GOAL_AREA_BL_CORNER"],
+                                                             self.point_dict["R_GOAL_AREA_BR_CORNER"])
+        self.line_extremities["Small rect. right top"] = (self.point_dict["R_GOAL_AREA_TL_CORNER"],
+                                                          self.point_dict["R_GOAL_AREA_TR_CORNER"])
+        self.line_extremities["Small rect. right main"] = (self.point_dict["R_GOAL_AREA_TL_CORNER"],
+                                                           self.point_dict["R_GOAL_AREA_BL_CORNER"])
+
+        self.line_extremities["Side line top"] = (self.point_dict["TL_PITCH_CORNER"],
+                                                  self.point_dict["TR_PITCH_CORNER"])
+        self.line_extremities["Side line bottom"] = (self.point_dict["BL_PITCH_CORNER"],
+                                                     self.point_dict["BR_PITCH_CORNER"])
+        self.line_extremities["Side line left"] = (self.point_dict["TL_PITCH_CORNER"],
+                                                   self.point_dict["BL_PITCH_CORNER"])
+        self.line_extremities["Side line right"] = (self.point_dict["TR_PITCH_CORNER"],
+                                                    self.point_dict["BR_PITCH_CORNER"])
+        self.line_extremities["Middle line"] = (self.point_dict["T_TOUCH_AND_HALFWAY_LINES_INTERSECTION"],
+                                                self.point_dict["B_TOUCH_AND_HALFWAY_LINES_INTERSECTION"])
+
+        self.line_extremities["Goal left crossbar"] = (self.point_dict["L_GOAL_TR_POST"],
+                                                       self.point_dict["L_GOAL_TL_POST"])
+        self.line_extremities["Goal left post left "] = (self.point_dict["L_GOAL_TL_POST"],
+                                                         self.point_dict["L_GOAL_BL_POST"])
+        self.line_extremities["Goal left post right"] = (self.point_dict["L_GOAL_TR_POST"],
+                                                         self.point_dict["L_GOAL_BR_POST"])
+
+        self.line_extremities["Goal right crossbar"] = (self.point_dict["R_GOAL_TL_POST"],
+                                                        self.point_dict["R_GOAL_TR_POST"])
+        self.line_extremities["Goal right post left"] = (self.point_dict["R_GOAL_TL_POST"],
+                                                         self.point_dict["R_GOAL_BL_POST"])
+        self.line_extremities["Goal right post right"] = (self.point_dict["R_GOAL_TR_POST"],
+                                                          self.point_dict["R_GOAL_BR_POST"])
+        self.line_extremities["Circle right"] = (self.point_dict["TR_16M_LINE_AND_PENALTY_ARC_INTERSECTION"],
+                                                 self.point_dict["BR_16M_LINE_AND_PENALTY_ARC_INTERSECTION"])
+        self.line_extremities["Circle left"] = (self.point_dict["TL_16M_LINE_AND_PENALTY_ARC_INTERSECTION"],
+                                                self.point_dict["BL_16M_LINE_AND_PENALTY_ARC_INTERSECTION"])
+
+        self.line_extremities_keys = dict()
+        self.line_extremities_keys["Big rect. left bottom"] = ("L_PENALTY_AREA_BL_CORNER",
+                                                               "L_PENALTY_AREA_BR_CORNER")
+        self.line_extremities_keys["Big rect. left top"] = ("L_PENALTY_AREA_TL_CORNER",
+                                                            "L_PENALTY_AREA_TR_CORNER")
+        self.line_extremities_keys["Big rect. left main"] = ("L_PENALTY_AREA_TR_CORNER",
+                                                             "L_PENALTY_AREA_BR_CORNER")
+        self.line_extremities_keys["Big rect. right bottom"] = ("R_PENALTY_AREA_BL_CORNER",
+                                                                "R_PENALTY_AREA_BR_CORNER")
+        self.line_extremities_keys["Big rect. right top"] = ("R_PENALTY_AREA_TL_CORNER",
+                                                             "R_PENALTY_AREA_TR_CORNER")
+        self.line_extremities_keys["Big rect. right main"] = ("R_PENALTY_AREA_TL_CORNER",
+                                                              "R_PENALTY_AREA_BL_CORNER")
+
+        self.line_extremities_keys["Small rect. left bottom"] = ("L_GOAL_AREA_BL_CORNER",
+                                                                 "L_GOAL_AREA_BR_CORNER")
+        self.line_extremities_keys["Small rect. left top"] = ("L_GOAL_AREA_TL_CORNER",
+                                                              "L_GOAL_AREA_TR_CORNER")
+        self.line_extremities_keys["Small rect. left main"] = ("L_GOAL_AREA_TR_CORNER",
+                                                               "L_GOAL_AREA_BR_CORNER")
+        self.line_extremities_keys["Small rect. right bottom"] = ("R_GOAL_AREA_BL_CORNER",
+                                                                  "R_GOAL_AREA_BR_CORNER")
+        self.line_extremities_keys["Small rect. right top"] = ("R_GOAL_AREA_TL_CORNER",
+                                                               "R_GOAL_AREA_TR_CORNER")
+        self.line_extremities_keys["Small rect. right main"] = ("R_GOAL_AREA_TL_CORNER",
+                                                                "R_GOAL_AREA_BL_CORNER")
+
+        self.line_extremities_keys["Side line top"] = ("TL_PITCH_CORNER",
+                                                       "TR_PITCH_CORNER")
+        self.line_extremities_keys["Side line bottom"] = ("BL_PITCH_CORNER",
+                                                          "BR_PITCH_CORNER")
+        self.line_extremities_keys["Side line left"] = ("TL_PITCH_CORNER",
+                                                        "BL_PITCH_CORNER")
+        self.line_extremities_keys["Side line right"] = ("TR_PITCH_CORNER",
+                                                         "BR_PITCH_CORNER")
+        self.line_extremities_keys["Middle line"] = ("T_TOUCH_AND_HALFWAY_LINES_INTERSECTION",
+                                                     "B_TOUCH_AND_HALFWAY_LINES_INTERSECTION")
+
+        self.line_extremities_keys["Goal left crossbar"] = ("L_GOAL_TR_POST",
+                                                            "L_GOAL_TL_POST")
+        self.line_extremities_keys["Goal left post left "] = ("L_GOAL_TL_POST",
+                                                              "L_GOAL_BL_POST")
+        self.line_extremities_keys["Goal left post right"] = ("L_GOAL_TR_POST",
+                                                              "L_GOAL_BR_POST")
+
+        self.line_extremities_keys["Goal right crossbar"] = ("R_GOAL_TL_POST",
+                                                             "R_GOAL_TR_POST")
+        self.line_extremities_keys["Goal right post left"] = ("R_GOAL_TL_POST",
+                                                              "R_GOAL_BL_POST")
+        self.line_extremities_keys["Goal right post right"] = ("R_GOAL_TR_POST",
+                                                               "R_GOAL_BR_POST")
+        self.line_extremities_keys["Circle right"] = ("TR_16M_LINE_AND_PENALTY_ARC_INTERSECTION",
+                                                      "BR_16M_LINE_AND_PENALTY_ARC_INTERSECTION")
+        self.line_extremities_keys["Circle left"] = ("TL_16M_LINE_AND_PENALTY_ARC_INTERSECTION",
+                                                     "BL_16M_LINE_AND_PENALTY_ARC_INTERSECTION")
+
+    def points(self):
+        return [
+            self.center_mark,
+            self.halfway_and_bottom_touch_line_mark,
+            self.halfway_and_top_touch_line_mark,
+            self.halfway_line_and_center_circle_top_mark,
+            self.halfway_line_and_center_circle_bottom_mark,
+            self.bottom_right_corner,
+            self.bottom_left_corner,
+            self.top_right_corner,
+            self.top_left_corner,
+            self.left_penalty_mark,
+            self.right_penalty_mark,
+            self.left_penalty_area_top_right_corner,
+            self.left_penalty_area_top_left_corner,
+            self.left_penalty_area_bottom_right_corner,
+            self.left_penalty_area_bottom_left_corner,
+            self.right_penalty_area_top_right_corner,
+            self.right_penalty_area_top_left_corner,
+            self.right_penalty_area_bottom_right_corner,
+            self.right_penalty_area_bottom_left_corner,
+            self.left_goal_area_top_right_corner,
+            self.left_goal_area_top_left_corner,
+            self.left_goal_area_bottom_right_corner,
+            self.left_goal_area_bottom_left_corner,
+            self.right_goal_area_top_right_corner,
+            self.right_goal_area_top_left_corner,
+            self.right_goal_area_bottom_right_corner,
+            self.right_goal_area_bottom_left_corner,
+            self.top_left_16M_penalty_arc_mark,
+            self.top_right_16M_penalty_arc_mark,
+            self.bottom_left_16M_penalty_arc_mark,
+            self.bottom_right_16M_penalty_arc_mark,
+            self.left_goal_top_left_post,
+            self.left_goal_top_right_post,
+            self.left_goal_bottom_left_post,
+            self.left_goal_bottom_right_post,
+            self.right_goal_top_left_post,
+            self.right_goal_top_right_post,
+            self.right_goal_bottom_left_post,
+            self.right_goal_bottom_right_post
+        ]
+
+    def sample_field_points(self, dist=0.1, dist_circles=0.2):
+        """
+        Samples each pitch element every dist meters, returns a dictionary associating the class of the element with a list of points sampled along this element.
+        :param dist: the distance in meters between each point sampled
+        :param dist_circles: the distance in meters between each point sampled on circles
+        :return:  a dictionary associating the class of the element with a list of points sampled along this element.
+        """
+        polylines = dict()
+        center = self.point_dict["CENTER_MARK"]
+        fromAngle = 0.
+        toAngle = 2 * np.pi
+
+        if toAngle < fromAngle:
+            toAngle += 2 * np.pi
+        x1 = center[0] + np.cos(fromAngle) * SoccerPitch.CENTER_CIRCLE_RADIUS
+        y1 = center[1] + np.sin(fromAngle) * SoccerPitch.CENTER_CIRCLE_RADIUS
+        z1 = 0.
+        point = np.array((x1, y1, z1))
+        polyline = [point]
+        length = SoccerPitch.CENTER_CIRCLE_RADIUS * (toAngle - fromAngle)
+        nb_pts = int(length / dist_circles)
+        dangle = dist_circles / SoccerPitch.CENTER_CIRCLE_RADIUS
+        for i in range(1, nb_pts):
+            angle = fromAngle + i * dangle
+            x = center[0] + np.cos(angle) * SoccerPitch.CENTER_CIRCLE_RADIUS
+            y = center[1] + np.sin(angle) * SoccerPitch.CENTER_CIRCLE_RADIUS
+            z = 0
+            point = np.array((x, y, z))
+            polyline.append(point)
+        polylines["Circle central"] = polyline
+        for key, line in self.line_extremities.items():
+
+            if "Circle" in key:
+                if key == "Circle right":
+                    top = self.point_dict["TR_16M_LINE_AND_PENALTY_ARC_INTERSECTION"]
+                    bottom = self.point_dict["BR_16M_LINE_AND_PENALTY_ARC_INTERSECTION"]
+                    center = self.point_dict["R_PENALTY_MARK"]
+                    toAngle = np.arctan2(top[1] - center[1],
+                                         top[0] - center[0]) + 2 * np.pi
+                    fromAngle = np.arctan2(bottom[1] - center[1],
+                                           bottom[0] - center[0]) + 2 * np.pi
+                elif key == "Circle left":
+                    top = self.point_dict["TL_16M_LINE_AND_PENALTY_ARC_INTERSECTION"]
+                    bottom = self.point_dict["BL_16M_LINE_AND_PENALTY_ARC_INTERSECTION"]
+                    center = self.point_dict["L_PENALTY_MARK"]
+                    fromAngle = np.arctan2(top[1] - center[1],
+                                           top[0] - center[0]) + 2 * np.pi
+                    toAngle = np.arctan2(bottom[1] - center[1],
+                                         bottom[0] - center[0]) + 2 * np.pi
+                if toAngle < fromAngle:
+                    toAngle += 2 * np.pi
+                x1 = center[0] + np.cos(fromAngle) * SoccerPitch.CENTER_CIRCLE_RADIUS
+                y1 = center[1] + np.sin(fromAngle) * SoccerPitch.CENTER_CIRCLE_RADIUS
+                z1 = 0.
+                xn = center[0] + np.cos(toAngle) * SoccerPitch.CENTER_CIRCLE_RADIUS
+                yn = center[1] + np.sin(toAngle) * SoccerPitch.CENTER_CIRCLE_RADIUS
+                zn = 0.
+                start = np.array((x1, y1, z1))
+                end = np.array((xn, yn, zn))
+                polyline = [start]
+                length = SoccerPitch.CENTER_CIRCLE_RADIUS * (toAngle - fromAngle)
+                nb_pts = int(length / dist_circles)
+                dangle = dist_circles / SoccerPitch.CENTER_CIRCLE_RADIUS
+                for i in range(1, nb_pts + 1):
+                    angle = fromAngle + i * dangle
+                    x = center[0] + np.cos(angle) * SoccerPitch.CENTER_CIRCLE_RADIUS
+                    y = center[1] + np.sin(angle) * SoccerPitch.CENTER_CIRCLE_RADIUS
+                    z = 0
+                    point = np.array((x, y, z))
+                    polyline.append(point)
+                polyline.append(end)
+                polylines[key] = polyline
+            else:
+                start = line[0]
+                end = line[1]
+
+                polyline = [start]
+
+                total_dist = np.sqrt(np.sum(np.square(start - end)))
+                nb_pts = int(total_dist / dist - 1)
+
+                v = end - start
+                v /= np.linalg.norm(v)
+                prev_pt = start
+                for i in range(nb_pts):
+                    pt = prev_pt + dist * v
+                    prev_pt = pt
+                    polyline.append(pt)
+                polyline.append(end)
+                polylines[key] = polyline
+        return polylines
+
+    def get_2d_homogeneous_line(self, line_name):
+        """
+        For lines belonging to the pitch lawn plane returns its 2D homogenous equation coefficients
+        :param line_name
+        :return: an array containing the three coefficients of the line
+        """
+        # ensure line in football pitch plane
+        if line_name in self.line_extremities.keys() and \
+                "post" not in line_name and \
+                "crossbar" not in line_name and "Circle" not in line_name:
+            extremities = self.line_extremities[line_name]
+            p1 = np.array([extremities[0][0], extremities[0][1], 1], dtype="float")
+            p2 = np.array([extremities[1][0], extremities[1][1], 1], dtype="float")
+            line = np.cross(p1, p2)
+
+            return line
+        return None