diff --git a/CenterNet/.gitignore b/CenterNet/.gitignore
new file mode 100644
index 0000000..cc1dded
--- /dev/null
+++ b/CenterNet/.gitignore
@@ -0,0 +1,111 @@
+legacy/*
+.DS_Store
+debug/*
+*.DS_Store
+*.json
+*.mat
+src/.vscode/*
+preds/*
+*.h5
+*.pth
+*.checkpoint
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+# Usually these files are written by a python script from a template
+# before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# dotenv
+.env
+
+# virtualenv
+.venv
+venv/
+ENV/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
diff --git a/CenterNet/.idea/workspace.xml b/CenterNet/.idea/workspace.xml
new file mode 100644
index 0000000..8326827
--- /dev/null
+++ b/CenterNet/.idea/workspace.xml
@@ -0,0 +1,258 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Ce
+ pre
+ dla34
+ pretrained
+ run
+ tot
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ 1559108082613
+
+
+ 1559108082613
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ file://$PROJECT_DIR$/src/lib/models/networks/pose_dla_dcn.py
+ 295
+
+
+
+ file://$PROJECT_DIR$/src/lib/models/networks/pose_dla_dcn.py
+ 296
+
+
+
+ file://$PROJECT_DIR$/src/lib/models/networks/pose_dla_dcn.py
+ 298
+
+
+
+ file://$PROJECT_DIR$/src/lib/detectors/ctdet.py
+ 25
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/CenterNet/.travis.yml b/CenterNet/.travis.yml
new file mode 100644
index 0000000..3dbd32f
--- /dev/null
+++ b/CenterNet/.travis.yml
@@ -0,0 +1,20 @@
+group: travis_latest
+dist: xenial # ubuntu-16.04
+language: python
+cache: pip
+python:
+ - 3.6
+ - 3.7
+install:
+ - pip install flake8
+ - pip install -r requirements.txt
+before_script:
+ # stop the build if there are Python syntax errors or undefined names
+ - flake8 . --count --select=E9,F63,F72,F82 --show-source --statistics
+ # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+ - flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+script:
+ - true # add other tests here
+notifications:
+ on_success: change
+ on_failure: change # `always` will be the setting once code changes slow down
diff --git a/CenterNet/experiments/ctdet_coco_resdcn18.sh b/CenterNet/experiments/ctdet_coco_resdcn18.sh
index 4a92f54..298fa8c 100644
--- a/CenterNet/experiments/ctdet_coco_resdcn18.sh
+++ b/CenterNet/experiments/ctdet_coco_resdcn18.sh
@@ -8,3 +8,5 @@ python test.py ctdet --exp_id coco_resdcn18 --arch resdcn_18 --keep_res --resume
# multi scale test
python test.py ctdet --exp_id coco_resdcn18 --arch resdcn_18 --keep_res --resume --flip_test --test_scales 0.5,0.75,1,1.25,1.5
cd ..
+
+
diff --git a/CenterNet/models/ctdet_coco_dla_2x.pth b/CenterNet/models/ctdet_coco_dla_2x.pth
new file mode 100644
index 0000000..3eb8058
Binary files /dev/null and b/CenterNet/models/ctdet_coco_dla_2x.pth differ
diff --git a/CenterNet/src/__pycache__/_init_paths.cpython-36.pyc b/CenterNet/src/__pycache__/_init_paths.cpython-36.pyc
new file mode 100644
index 0000000..2fbb8f3
Binary files /dev/null and b/CenterNet/src/__pycache__/_init_paths.cpython-36.pyc differ
diff --git a/CenterNet/src/lib/__pycache__/opts.cpython-36.pyc b/CenterNet/src/lib/__pycache__/opts.cpython-36.pyc
new file mode 100644
index 0000000..0480696
Binary files /dev/null and b/CenterNet/src/lib/__pycache__/opts.cpython-36.pyc differ
diff --git a/CenterNet/src/lib/detectors/__pycache__/base_detector.cpython-36.pyc b/CenterNet/src/lib/detectors/__pycache__/base_detector.cpython-36.pyc
new file mode 100644
index 0000000..021143a
Binary files /dev/null and b/CenterNet/src/lib/detectors/__pycache__/base_detector.cpython-36.pyc differ
diff --git a/CenterNet/src/lib/detectors/__pycache__/ctdet.cpython-36.pyc b/CenterNet/src/lib/detectors/__pycache__/ctdet.cpython-36.pyc
new file mode 100644
index 0000000..1b4636e
Binary files /dev/null and b/CenterNet/src/lib/detectors/__pycache__/ctdet.cpython-36.pyc differ
diff --git a/CenterNet/src/lib/detectors/__pycache__/ddd.cpython-36.pyc b/CenterNet/src/lib/detectors/__pycache__/ddd.cpython-36.pyc
new file mode 100644
index 0000000..bc4ca0e
Binary files /dev/null and b/CenterNet/src/lib/detectors/__pycache__/ddd.cpython-36.pyc differ
diff --git a/CenterNet/src/lib/detectors/__pycache__/detector_factory.cpython-36.pyc b/CenterNet/src/lib/detectors/__pycache__/detector_factory.cpython-36.pyc
new file mode 100644
index 0000000..085ad76
Binary files /dev/null and b/CenterNet/src/lib/detectors/__pycache__/detector_factory.cpython-36.pyc differ
diff --git a/CenterNet/src/lib/detectors/__pycache__/exdet.cpython-36.pyc b/CenterNet/src/lib/detectors/__pycache__/exdet.cpython-36.pyc
new file mode 100644
index 0000000..68986b4
Binary files /dev/null and b/CenterNet/src/lib/detectors/__pycache__/exdet.cpython-36.pyc differ
diff --git a/CenterNet/src/lib/detectors/__pycache__/multi_pose.cpython-36.pyc b/CenterNet/src/lib/detectors/__pycache__/multi_pose.cpython-36.pyc
new file mode 100644
index 0000000..9d32392
Binary files /dev/null and b/CenterNet/src/lib/detectors/__pycache__/multi_pose.cpython-36.pyc differ
diff --git a/CenterNet/src/lib/detectors/exdet.py b/CenterNet/src/lib/detectors/exdet.py
index f121f61..6b6f9f1 100755
--- a/CenterNet/src/lib/detectors/exdet.py
+++ b/CenterNet/src/lib/detectors/exdet.py
@@ -2,7 +2,7 @@
from __future__ import division
from __future__ import print_function
-import _init_paths
+#import _init_paths
import sys
import os
diff --git a/CenterNet/src/lib/external/__pycache__/__init__.cpython-36.pyc b/CenterNet/src/lib/external/__pycache__/__init__.cpython-36.pyc
new file mode 100644
index 0000000..51423dd
Binary files /dev/null and b/CenterNet/src/lib/external/__pycache__/__init__.cpython-36.pyc differ
diff --git a/CenterNet/src/lib/external/nms.c b/CenterNet/src/lib/external/nms.c
new file mode 100644
index 0000000..02d76b3
--- /dev/null
+++ b/CenterNet/src/lib/external/nms.c
@@ -0,0 +1,15802 @@
+/* Generated by Cython 0.29.9 */
+
+/* BEGIN: Cython Metadata
+{
+ "distutils": {
+ "depends": [],
+ "extra_compile_args": [
+ "-Wno-cpp",
+ "-Wno-unused-function"
+ ],
+ "name": "nms",
+ "sources": [
+ "nms.pyx"
+ ]
+ },
+ "module_name": "nms"
+}
+END: Cython Metadata */
+
+#define PY_SSIZE_T_CLEAN
+#include "Python.h"
+#ifndef Py_PYTHON_H
+ #error Python headers needed to compile C extensions, please install development version of Python.
+#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
+ #error Cython requires Python 2.6+ or Python 3.3+.
+#else
+#define CYTHON_ABI "0_29_9"
+#define CYTHON_HEX_VERSION 0x001D09F0
+#define CYTHON_FUTURE_DIVISION 0
+#include
+#ifndef offsetof
+ #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
+#endif
+#if !defined(WIN32) && !defined(MS_WINDOWS)
+ #ifndef __stdcall
+ #define __stdcall
+ #endif
+ #ifndef __cdecl
+ #define __cdecl
+ #endif
+ #ifndef __fastcall
+ #define __fastcall
+ #endif
+#endif
+#ifndef DL_IMPORT
+ #define DL_IMPORT(t) t
+#endif
+#ifndef DL_EXPORT
+ #define DL_EXPORT(t) t
+#endif
+#define __PYX_COMMA ,
+#ifndef HAVE_LONG_LONG
+ #if PY_VERSION_HEX >= 0x02070000
+ #define HAVE_LONG_LONG
+ #endif
+#endif
+#ifndef PY_LONG_LONG
+ #define PY_LONG_LONG LONG_LONG
+#endif
+#ifndef Py_HUGE_VAL
+ #define Py_HUGE_VAL HUGE_VAL
+#endif
+#ifdef PYPY_VERSION
+ #define CYTHON_COMPILING_IN_PYPY 1
+ #define CYTHON_COMPILING_IN_PYSTON 0
+ #define CYTHON_COMPILING_IN_CPYTHON 0
+ #undef CYTHON_USE_TYPE_SLOTS
+ #define CYTHON_USE_TYPE_SLOTS 0
+ #undef CYTHON_USE_PYTYPE_LOOKUP
+ #define CYTHON_USE_PYTYPE_LOOKUP 0
+ #if PY_VERSION_HEX < 0x03050000
+ #undef CYTHON_USE_ASYNC_SLOTS
+ #define CYTHON_USE_ASYNC_SLOTS 0
+ #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+ #define CYTHON_USE_ASYNC_SLOTS 1
+ #endif
+ #undef CYTHON_USE_PYLIST_INTERNALS
+ #define CYTHON_USE_PYLIST_INTERNALS 0
+ #undef CYTHON_USE_UNICODE_INTERNALS
+ #define CYTHON_USE_UNICODE_INTERNALS 0
+ #undef CYTHON_USE_UNICODE_WRITER
+ #define CYTHON_USE_UNICODE_WRITER 0
+ #undef CYTHON_USE_PYLONG_INTERNALS
+ #define CYTHON_USE_PYLONG_INTERNALS 0
+ #undef CYTHON_AVOID_BORROWED_REFS
+ #define CYTHON_AVOID_BORROWED_REFS 1
+ #undef CYTHON_ASSUME_SAFE_MACROS
+ #define CYTHON_ASSUME_SAFE_MACROS 0
+ #undef CYTHON_UNPACK_METHODS
+ #define CYTHON_UNPACK_METHODS 0
+ #undef CYTHON_FAST_THREAD_STATE
+ #define CYTHON_FAST_THREAD_STATE 0
+ #undef CYTHON_FAST_PYCALL
+ #define CYTHON_FAST_PYCALL 0
+ #undef CYTHON_PEP489_MULTI_PHASE_INIT
+ #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+ #undef CYTHON_USE_TP_FINALIZE
+ #define CYTHON_USE_TP_FINALIZE 0
+ #undef CYTHON_USE_DICT_VERSIONS
+ #define CYTHON_USE_DICT_VERSIONS 0
+ #undef CYTHON_USE_EXC_INFO_STACK
+ #define CYTHON_USE_EXC_INFO_STACK 0
+#elif defined(PYSTON_VERSION)
+ #define CYTHON_COMPILING_IN_PYPY 0
+ #define CYTHON_COMPILING_IN_PYSTON 1
+ #define CYTHON_COMPILING_IN_CPYTHON 0
+ #ifndef CYTHON_USE_TYPE_SLOTS
+ #define CYTHON_USE_TYPE_SLOTS 1
+ #endif
+ #undef CYTHON_USE_PYTYPE_LOOKUP
+ #define CYTHON_USE_PYTYPE_LOOKUP 0
+ #undef CYTHON_USE_ASYNC_SLOTS
+ #define CYTHON_USE_ASYNC_SLOTS 0
+ #undef CYTHON_USE_PYLIST_INTERNALS
+ #define CYTHON_USE_PYLIST_INTERNALS 0
+ #ifndef CYTHON_USE_UNICODE_INTERNALS
+ #define CYTHON_USE_UNICODE_INTERNALS 1
+ #endif
+ #undef CYTHON_USE_UNICODE_WRITER
+ #define CYTHON_USE_UNICODE_WRITER 0
+ #undef CYTHON_USE_PYLONG_INTERNALS
+ #define CYTHON_USE_PYLONG_INTERNALS 0
+ #ifndef CYTHON_AVOID_BORROWED_REFS
+ #define CYTHON_AVOID_BORROWED_REFS 0
+ #endif
+ #ifndef CYTHON_ASSUME_SAFE_MACROS
+ #define CYTHON_ASSUME_SAFE_MACROS 1
+ #endif
+ #ifndef CYTHON_UNPACK_METHODS
+ #define CYTHON_UNPACK_METHODS 1
+ #endif
+ #undef CYTHON_FAST_THREAD_STATE
+ #define CYTHON_FAST_THREAD_STATE 0
+ #undef CYTHON_FAST_PYCALL
+ #define CYTHON_FAST_PYCALL 0
+ #undef CYTHON_PEP489_MULTI_PHASE_INIT
+ #define CYTHON_PEP489_MULTI_PHASE_INIT 0
+ #undef CYTHON_USE_TP_FINALIZE
+ #define CYTHON_USE_TP_FINALIZE 0
+ #undef CYTHON_USE_DICT_VERSIONS
+ #define CYTHON_USE_DICT_VERSIONS 0
+ #undef CYTHON_USE_EXC_INFO_STACK
+ #define CYTHON_USE_EXC_INFO_STACK 0
+#else
+ #define CYTHON_COMPILING_IN_PYPY 0
+ #define CYTHON_COMPILING_IN_PYSTON 0
+ #define CYTHON_COMPILING_IN_CPYTHON 1
+ #ifndef CYTHON_USE_TYPE_SLOTS
+ #define CYTHON_USE_TYPE_SLOTS 1
+ #endif
+ #if PY_VERSION_HEX < 0x02070000
+ #undef CYTHON_USE_PYTYPE_LOOKUP
+ #define CYTHON_USE_PYTYPE_LOOKUP 0
+ #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
+ #define CYTHON_USE_PYTYPE_LOOKUP 1
+ #endif
+ #if PY_MAJOR_VERSION < 3
+ #undef CYTHON_USE_ASYNC_SLOTS
+ #define CYTHON_USE_ASYNC_SLOTS 0
+ #elif !defined(CYTHON_USE_ASYNC_SLOTS)
+ #define CYTHON_USE_ASYNC_SLOTS 1
+ #endif
+ #if PY_VERSION_HEX < 0x02070000
+ #undef CYTHON_USE_PYLONG_INTERNALS
+ #define CYTHON_USE_PYLONG_INTERNALS 0
+ #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
+ #define CYTHON_USE_PYLONG_INTERNALS 1
+ #endif
+ #ifndef CYTHON_USE_PYLIST_INTERNALS
+ #define CYTHON_USE_PYLIST_INTERNALS 1
+ #endif
+ #ifndef CYTHON_USE_UNICODE_INTERNALS
+ #define CYTHON_USE_UNICODE_INTERNALS 1
+ #endif
+ #if PY_VERSION_HEX < 0x030300F0
+ #undef CYTHON_USE_UNICODE_WRITER
+ #define CYTHON_USE_UNICODE_WRITER 0
+ #elif !defined(CYTHON_USE_UNICODE_WRITER)
+ #define CYTHON_USE_UNICODE_WRITER 1
+ #endif
+ #ifndef CYTHON_AVOID_BORROWED_REFS
+ #define CYTHON_AVOID_BORROWED_REFS 0
+ #endif
+ #ifndef CYTHON_ASSUME_SAFE_MACROS
+ #define CYTHON_ASSUME_SAFE_MACROS 1
+ #endif
+ #ifndef CYTHON_UNPACK_METHODS
+ #define CYTHON_UNPACK_METHODS 1
+ #endif
+ #ifndef CYTHON_FAST_THREAD_STATE
+ #define CYTHON_FAST_THREAD_STATE 1
+ #endif
+ #ifndef CYTHON_FAST_PYCALL
+ #define CYTHON_FAST_PYCALL 1
+ #endif
+ #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
+ #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000)
+ #endif
+ #ifndef CYTHON_USE_TP_FINALIZE
+ #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
+ #endif
+ #ifndef CYTHON_USE_DICT_VERSIONS
+ #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1)
+ #endif
+ #ifndef CYTHON_USE_EXC_INFO_STACK
+ #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3)
+ #endif
+#endif
+#if !defined(CYTHON_FAST_PYCCALL)
+#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
+#endif
+#if CYTHON_USE_PYLONG_INTERNALS
+ #include "longintrepr.h"
+ #undef SHIFT
+ #undef BASE
+ #undef MASK
+ #ifdef SIZEOF_VOID_P
+ enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) };
+ #endif
+#endif
+#ifndef __has_attribute
+ #define __has_attribute(x) 0
+#endif
+#ifndef __has_cpp_attribute
+ #define __has_cpp_attribute(x) 0
+#endif
+#ifndef CYTHON_RESTRICT
+ #if defined(__GNUC__)
+ #define CYTHON_RESTRICT __restrict__
+ #elif defined(_MSC_VER) && _MSC_VER >= 1400
+ #define CYTHON_RESTRICT __restrict
+ #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+ #define CYTHON_RESTRICT restrict
+ #else
+ #define CYTHON_RESTRICT
+ #endif
+#endif
+#ifndef CYTHON_UNUSED
+# if defined(__GNUC__)
+# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
+# define CYTHON_UNUSED __attribute__ ((__unused__))
+# else
+# define CYTHON_UNUSED
+# endif
+# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
+# define CYTHON_UNUSED __attribute__ ((__unused__))
+# else
+# define CYTHON_UNUSED
+# endif
+#endif
+#ifndef CYTHON_MAYBE_UNUSED_VAR
+# if defined(__cplusplus)
+ template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
+# else
+# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
+# endif
+#endif
+#ifndef CYTHON_NCP_UNUSED
+# if CYTHON_COMPILING_IN_CPYTHON
+# define CYTHON_NCP_UNUSED
+# else
+# define CYTHON_NCP_UNUSED CYTHON_UNUSED
+# endif
+#endif
+#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
+#ifdef _MSC_VER
+ #ifndef _MSC_STDINT_H_
+ #if _MSC_VER < 1300
+ typedef unsigned char uint8_t;
+ typedef unsigned int uint32_t;
+ #else
+ typedef unsigned __int8 uint8_t;
+ typedef unsigned __int32 uint32_t;
+ #endif
+ #endif
+#else
+ #include
+#endif
+#ifndef CYTHON_FALLTHROUGH
+ #if defined(__cplusplus) && __cplusplus >= 201103L
+ #if __has_cpp_attribute(fallthrough)
+ #define CYTHON_FALLTHROUGH [[fallthrough]]
+ #elif __has_cpp_attribute(clang::fallthrough)
+ #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
+ #elif __has_cpp_attribute(gnu::fallthrough)
+ #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
+ #endif
+ #endif
+ #ifndef CYTHON_FALLTHROUGH
+ #if __has_attribute(fallthrough)
+ #define CYTHON_FALLTHROUGH __attribute__((fallthrough))
+ #else
+ #define CYTHON_FALLTHROUGH
+ #endif
+ #endif
+ #if defined(__clang__ ) && defined(__apple_build_version__)
+ #if __apple_build_version__ < 7000000
+ #undef CYTHON_FALLTHROUGH
+ #define CYTHON_FALLTHROUGH
+ #endif
+ #endif
+#endif
+
+#ifndef CYTHON_INLINE
+ #if defined(__clang__)
+ #define CYTHON_INLINE __inline__ __attribute__ ((__unused__))
+ #elif defined(__GNUC__)
+ #define CYTHON_INLINE __inline__
+ #elif defined(_MSC_VER)
+ #define CYTHON_INLINE __inline
+ #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+ #define CYTHON_INLINE inline
+ #else
+ #define CYTHON_INLINE
+ #endif
+#endif
+
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
+ #define Py_OptimizeFlag 0
+#endif
+#define __PYX_BUILD_PY_SSIZE_T "n"
+#define CYTHON_FORMAT_SSIZE_T "z"
+#if PY_MAJOR_VERSION < 3
+ #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
+ #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+ #define __Pyx_DefaultClassType PyClass_Type
+#else
+ #define __Pyx_BUILTIN_MODULE_NAME "builtins"
+#if PY_VERSION_HEX < 0x030800A4
+ #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+#else
+ #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
+ PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
+#endif
+ #define __Pyx_DefaultClassType PyType_Type
+#endif
+#ifndef Py_TPFLAGS_CHECKTYPES
+ #define Py_TPFLAGS_CHECKTYPES 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_INDEX
+ #define Py_TPFLAGS_HAVE_INDEX 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
+ #define Py_TPFLAGS_HAVE_NEWBUFFER 0
+#endif
+#ifndef Py_TPFLAGS_HAVE_FINALIZE
+ #define Py_TPFLAGS_HAVE_FINALIZE 0
+#endif
+#ifndef METH_STACKLESS
+ #define METH_STACKLESS 0
+#endif
+#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL)
+ #ifndef METH_FASTCALL
+ #define METH_FASTCALL 0x80
+ #endif
+ typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs);
+ typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
+ Py_ssize_t nargs, PyObject *kwnames);
+#else
+ #define __Pyx_PyCFunctionFast _PyCFunctionFast
+ #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
+#endif
+#if CYTHON_FAST_PYCCALL
+#define __Pyx_PyFastCFunction_Check(func)\
+ ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS)))))
+#else
+#define __Pyx_PyFastCFunction_Check(func) 0
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
+ #define PyObject_Malloc(s) PyMem_Malloc(s)
+ #define PyObject_Free(p) PyMem_Free(p)
+ #define PyObject_Realloc(p) PyMem_Realloc(p)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1
+ #define PyMem_RawMalloc(n) PyMem_Malloc(n)
+ #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n)
+ #define PyMem_RawFree(p) PyMem_Free(p)
+#endif
+#if CYTHON_COMPILING_IN_PYSTON
+ #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co)
+ #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
+#else
+ #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0)
+ #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno)
+#endif
+#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
+ #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#elif PY_VERSION_HEX >= 0x03060000
+ #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
+#elif PY_VERSION_HEX >= 0x03000000
+ #define __Pyx_PyThreadState_Current PyThreadState_GET()
+#else
+ #define __Pyx_PyThreadState_Current _PyThreadState_Current
+#endif
+#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
+#include "pythread.h"
+#define Py_tss_NEEDS_INIT 0
+typedef int Py_tss_t;
+static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) {
+ *key = PyThread_create_key();
+ return 0;
+}
+static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) {
+ Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t));
+ *key = Py_tss_NEEDS_INIT;
+ return key;
+}
+static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) {
+ PyObject_Free(key);
+}
+static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) {
+ return *key != Py_tss_NEEDS_INIT;
+}
+static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) {
+ PyThread_delete_key(*key);
+ *key = Py_tss_NEEDS_INIT;
+}
+static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) {
+ return PyThread_set_key_value(*key, value);
+}
+static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
+ return PyThread_get_key_value(*key);
+}
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
+#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
+#else
+#define __Pyx_PyDict_NewPresized(n) PyDict_New()
+#endif
+#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION
+ #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y)
+ #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y)
+#else
+ #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y)
+ #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y)
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
+#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
+#else
+#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name)
+#endif
+#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
+ #define CYTHON_PEP393_ENABLED 1
+ #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\
+ 0 : _PyUnicode_Ready((PyObject *)(op)))
+ #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u)
+ #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
+ #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u)
+ #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u)
+ #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u)
+ #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i)
+ #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch)
+ #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
+#else
+ #define CYTHON_PEP393_ENABLED 0
+ #define PyUnicode_1BYTE_KIND 1
+ #define PyUnicode_2BYTE_KIND 2
+ #define PyUnicode_4BYTE_KIND 4
+ #define __Pyx_PyUnicode_READY(op) (0)
+ #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u)
+ #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
+ #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
+ #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE))
+ #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u))
+ #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
+ #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
+ #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u))
+#endif
+#if CYTHON_COMPILING_IN_PYPY
+ #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b)
+ #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b)
+#else
+ #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b)
+ #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
+ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
+ #define PyUnicode_Contains(u, s) PySequence_Contains(u, s)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
+ #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type)
+#endif
+#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
+ #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt)
+#endif
+#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
+#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
+#if PY_MAJOR_VERSION >= 3
+ #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b)
+#else
+ #define __Pyx_PyString_Format(a, b) PyString_Format(a, b)
+#endif
+#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
+ #define PyObject_ASCII(o) PyObject_Repr(o)
+#endif
+#if PY_MAJOR_VERSION >= 3
+ #define PyBaseString_Type PyUnicode_Type
+ #define PyStringObject PyUnicodeObject
+ #define PyString_Type PyUnicode_Type
+ #define PyString_Check PyUnicode_Check
+ #define PyString_CheckExact PyUnicode_CheckExact
+ #define PyObject_Unicode PyObject_Str
+#endif
+#if PY_MAJOR_VERSION >= 3
+ #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
+ #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
+#else
+ #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
+ #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
+#endif
+#ifndef PySet_CheckExact
+ #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type)
+#endif
+#if CYTHON_ASSUME_SAFE_MACROS
+ #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq)
+#else
+ #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq)
+#endif
+#if PY_MAJOR_VERSION >= 3
+ #define PyIntObject PyLongObject
+ #define PyInt_Type PyLong_Type
+ #define PyInt_Check(op) PyLong_Check(op)
+ #define PyInt_CheckExact(op) PyLong_CheckExact(op)
+ #define PyInt_FromString PyLong_FromString
+ #define PyInt_FromUnicode PyLong_FromUnicode
+ #define PyInt_FromLong PyLong_FromLong
+ #define PyInt_FromSize_t PyLong_FromSize_t
+ #define PyInt_FromSsize_t PyLong_FromSsize_t
+ #define PyInt_AsLong PyLong_AsLong
+ #define PyInt_AS_LONG PyLong_AS_LONG
+ #define PyInt_AsSsize_t PyLong_AsSsize_t
+ #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask
+ #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
+ #define PyNumber_Int PyNumber_Long
+#endif
+#if PY_MAJOR_VERSION >= 3
+ #define PyBoolObject PyLongObject
+#endif
+#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
+ #ifndef PyUnicode_InternFromString
+ #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
+ #endif
+#endif
+#if PY_VERSION_HEX < 0x030200A4
+ typedef long Py_hash_t;
+ #define __Pyx_PyInt_FromHash_t PyInt_FromLong
+ #define __Pyx_PyInt_AsHash_t PyInt_AsLong
+#else
+ #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
+ #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t
+#endif
+#if PY_MAJOR_VERSION >= 3
+ #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : (Py_INCREF(func), func))
+#else
+ #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
+#endif
+#if CYTHON_USE_ASYNC_SLOTS
+ #if PY_VERSION_HEX >= 0x030500B1
+ #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
+ #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)
+ #else
+ #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
+ #endif
+#else
+ #define __Pyx_PyType_AsAsync(obj) NULL
+#endif
+#ifndef __Pyx_PyAsyncMethodsStruct
+ typedef struct {
+ unaryfunc am_await;
+ unaryfunc am_aiter;
+ unaryfunc am_anext;
+ } __Pyx_PyAsyncMethodsStruct;
+#endif
+
+#if defined(WIN32) || defined(MS_WINDOWS)
+ #define _USE_MATH_DEFINES
+#endif
+#include
+#ifdef NAN
+#define __PYX_NAN() ((float) NAN)
+#else
+static CYTHON_INLINE float __PYX_NAN() {
+ float value;
+ memset(&value, 0xFF, sizeof(value));
+ return value;
+}
+#endif
+#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
+#define __Pyx_truncl trunc
+#else
+#define __Pyx_truncl truncl
+#endif
+
+
+#define __PYX_ERR(f_index, lineno, Ln_error) \
+{ \
+ __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \
+}
+
+#ifndef __PYX_EXTERN_C
+ #ifdef __cplusplus
+ #define __PYX_EXTERN_C extern "C"
+ #else
+ #define __PYX_EXTERN_C extern
+ #endif
+#endif
+
+#define __PYX_HAVE__nms
+#define __PYX_HAVE_API__nms
+/* Early includes */
+#include
+#include
+#include "numpy/arrayobject.h"
+#include "numpy/ufuncobject.h"
+#ifdef _OPENMP
+#include
+#endif /* _OPENMP */
+
+#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS)
+#define CYTHON_WITHOUT_ASSERTIONS
+#endif
+
+typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
+ const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;
+
+#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
+#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0
+#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8)
+#define __PYX_DEFAULT_STRING_ENCODING ""
+#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
+#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#define __Pyx_uchar_cast(c) ((unsigned char)c)
+#define __Pyx_long_cast(x) ((long)x)
+#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\
+ (sizeof(type) < sizeof(Py_ssize_t)) ||\
+ (sizeof(type) > sizeof(Py_ssize_t) &&\
+ likely(v < (type)PY_SSIZE_T_MAX ||\
+ v == (type)PY_SSIZE_T_MAX) &&\
+ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
+ v == (type)PY_SSIZE_T_MIN))) ||\
+ (sizeof(type) == sizeof(Py_ssize_t) &&\
+ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
+ v == (type)PY_SSIZE_T_MAX))) )
+static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
+ return (size_t) i < (size_t) limit;
+}
+#if defined (__cplusplus) && __cplusplus >= 201103L
+ #include
+ #define __Pyx_sst_abs(value) std::abs(value)
+#elif SIZEOF_INT >= SIZEOF_SIZE_T
+ #define __Pyx_sst_abs(value) abs(value)
+#elif SIZEOF_LONG >= SIZEOF_SIZE_T
+ #define __Pyx_sst_abs(value) labs(value)
+#elif defined (_MSC_VER)
+ #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value))
+#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+ #define __Pyx_sst_abs(value) llabs(value)
+#elif defined (__GNUC__)
+ #define __Pyx_sst_abs(value) __builtin_llabs(value)
+#else
+ #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
+#endif
+static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
+static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
+#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
+#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
+#define __Pyx_PyBytes_FromString PyBytes_FromString
+#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
+#if PY_MAJOR_VERSION < 3
+ #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString
+ #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#else
+ #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString
+ #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
+#endif
+#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s)
+#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s)
+#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s)
+#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s)
+#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
+static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
+ const Py_UNICODE *u_end = u;
+ while (*u_end++) ;
+ return (size_t)(u_end - u - 1);
+}
+#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
+#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
+#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode
+#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
+#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
+static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b);
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
+static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*);
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
+#define __Pyx_PySequence_Tuple(obj)\
+ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj))
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
+#if CYTHON_ASSUME_SAFE_MACROS
+#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
+#else
+#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
+#endif
+#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
+#if PY_MAJOR_VERSION >= 3
+#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
+#else
+#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
+#endif
+#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+static int __Pyx_sys_getdefaultencoding_not_ascii;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+ PyObject* sys;
+ PyObject* default_encoding = NULL;
+ PyObject* ascii_chars_u = NULL;
+ PyObject* ascii_chars_b = NULL;
+ const char* default_encoding_c;
+ sys = PyImport_ImportModule("sys");
+ if (!sys) goto bad;
+ default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
+ Py_DECREF(sys);
+ if (!default_encoding) goto bad;
+ default_encoding_c = PyBytes_AsString(default_encoding);
+ if (!default_encoding_c) goto bad;
+ if (strcmp(default_encoding_c, "ascii") == 0) {
+ __Pyx_sys_getdefaultencoding_not_ascii = 0;
+ } else {
+ char ascii_chars[128];
+ int c;
+ for (c = 0; c < 128; c++) {
+ ascii_chars[c] = c;
+ }
+ __Pyx_sys_getdefaultencoding_not_ascii = 1;
+ ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
+ if (!ascii_chars_u) goto bad;
+ ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
+ if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
+ PyErr_Format(
+ PyExc_ValueError,
+ "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
+ default_encoding_c);
+ goto bad;
+ }
+ Py_DECREF(ascii_chars_u);
+ Py_DECREF(ascii_chars_b);
+ }
+ Py_DECREF(default_encoding);
+ return 0;
+bad:
+ Py_XDECREF(default_encoding);
+ Py_XDECREF(ascii_chars_u);
+ Py_XDECREF(ascii_chars_b);
+ return -1;
+}
+#endif
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
+#else
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+static char* __PYX_DEFAULT_STRING_ENCODING;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+ PyObject* sys;
+ PyObject* default_encoding = NULL;
+ char* default_encoding_c;
+ sys = PyImport_ImportModule("sys");
+ if (!sys) goto bad;
+ default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
+ Py_DECREF(sys);
+ if (!default_encoding) goto bad;
+ default_encoding_c = PyBytes_AsString(default_encoding);
+ if (!default_encoding_c) goto bad;
+ __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1);
+ if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
+ strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
+ Py_DECREF(default_encoding);
+ return 0;
+bad:
+ Py_XDECREF(default_encoding);
+ return -1;
+}
+#endif
+#endif
+
+
+/* Test for GCC > 2.95 */
+#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
+ #define likely(x) __builtin_expect(!!(x), 1)
+ #define unlikely(x) __builtin_expect(!!(x), 0)
+#else /* !__GNUC__ or GCC < 2.95 */
+ #define likely(x) (x)
+ #define unlikely(x) (x)
+#endif /* __GNUC__ */
+static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }
+
+static PyObject *__pyx_m = NULL;
+static PyObject *__pyx_d;
+static PyObject *__pyx_b;
+static PyObject *__pyx_cython_runtime = NULL;
+static PyObject *__pyx_empty_tuple;
+static PyObject *__pyx_empty_bytes;
+static PyObject *__pyx_empty_unicode;
+static int __pyx_lineno;
+static int __pyx_clineno = 0;
+static const char * __pyx_cfilenm= __FILE__;
+static const char *__pyx_filename;
+
+/* Header.proto */
+#if !defined(CYTHON_CCOMPLEX)
+ #if defined(__cplusplus)
+ #define CYTHON_CCOMPLEX 1
+ #elif defined(_Complex_I)
+ #define CYTHON_CCOMPLEX 1
+ #else
+ #define CYTHON_CCOMPLEX 0
+ #endif
+#endif
+#if CYTHON_CCOMPLEX
+ #ifdef __cplusplus
+ #include
+ #else
+ #include
+ #endif
+#endif
+#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__)
+ #undef _Complex_I
+ #define _Complex_I 1.0fj
+#endif
+
+
+static const char *__pyx_f[] = {
+ "nms.pyx",
+ "__init__.pxd",
+ "type.pxd",
+};
+/* BufferFormatStructs.proto */
+#define IS_UNSIGNED(type) (((type) -1) > 0)
+struct __Pyx_StructField_;
+#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0)
+typedef struct {
+ const char* name;
+ struct __Pyx_StructField_* fields;
+ size_t size;
+ size_t arraysize[8];
+ int ndim;
+ char typegroup;
+ char is_unsigned;
+ int flags;
+} __Pyx_TypeInfo;
+typedef struct __Pyx_StructField_ {
+ __Pyx_TypeInfo* type;
+ const char* name;
+ size_t offset;
+} __Pyx_StructField;
+typedef struct {
+ __Pyx_StructField* field;
+ size_t parent_offset;
+} __Pyx_BufFmt_StackElem;
+typedef struct {
+ __Pyx_StructField root;
+ __Pyx_BufFmt_StackElem* head;
+ size_t fmt_offset;
+ size_t new_count, enc_count;
+ size_t struct_alignment;
+ int is_complex;
+ char enc_type;
+ char new_packmode;
+ char enc_packmode;
+ char is_valid_array;
+} __Pyx_BufFmt_Context;
+
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":776
+ * # in Cython to enable them only on the right systems.
+ *
+ * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<<
+ * ctypedef npy_int16 int16_t
+ * ctypedef npy_int32 int32_t
+ */
+typedef npy_int8 __pyx_t_5numpy_int8_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":777
+ *
+ * ctypedef npy_int8 int8_t
+ * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<<
+ * ctypedef npy_int32 int32_t
+ * ctypedef npy_int64 int64_t
+ */
+typedef npy_int16 __pyx_t_5numpy_int16_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":778
+ * ctypedef npy_int8 int8_t
+ * ctypedef npy_int16 int16_t
+ * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<<
+ * ctypedef npy_int64 int64_t
+ * #ctypedef npy_int96 int96_t
+ */
+typedef npy_int32 __pyx_t_5numpy_int32_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":779
+ * ctypedef npy_int16 int16_t
+ * ctypedef npy_int32 int32_t
+ * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<<
+ * #ctypedef npy_int96 int96_t
+ * #ctypedef npy_int128 int128_t
+ */
+typedef npy_int64 __pyx_t_5numpy_int64_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":783
+ * #ctypedef npy_int128 int128_t
+ *
+ * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<<
+ * ctypedef npy_uint16 uint16_t
+ * ctypedef npy_uint32 uint32_t
+ */
+typedef npy_uint8 __pyx_t_5numpy_uint8_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":784
+ *
+ * ctypedef npy_uint8 uint8_t
+ * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<<
+ * ctypedef npy_uint32 uint32_t
+ * ctypedef npy_uint64 uint64_t
+ */
+typedef npy_uint16 __pyx_t_5numpy_uint16_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":785
+ * ctypedef npy_uint8 uint8_t
+ * ctypedef npy_uint16 uint16_t
+ * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<<
+ * ctypedef npy_uint64 uint64_t
+ * #ctypedef npy_uint96 uint96_t
+ */
+typedef npy_uint32 __pyx_t_5numpy_uint32_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":786
+ * ctypedef npy_uint16 uint16_t
+ * ctypedef npy_uint32 uint32_t
+ * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<<
+ * #ctypedef npy_uint96 uint96_t
+ * #ctypedef npy_uint128 uint128_t
+ */
+typedef npy_uint64 __pyx_t_5numpy_uint64_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":790
+ * #ctypedef npy_uint128 uint128_t
+ *
+ * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<<
+ * ctypedef npy_float64 float64_t
+ * #ctypedef npy_float80 float80_t
+ */
+typedef npy_float32 __pyx_t_5numpy_float32_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":791
+ *
+ * ctypedef npy_float32 float32_t
+ * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<<
+ * #ctypedef npy_float80 float80_t
+ * #ctypedef npy_float128 float128_t
+ */
+typedef npy_float64 __pyx_t_5numpy_float64_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":800
+ * # The int types are mapped a bit surprising --
+ * # numpy.int corresponds to 'l' and numpy.long to 'q'
+ * ctypedef npy_long int_t # <<<<<<<<<<<<<<
+ * ctypedef npy_longlong long_t
+ * ctypedef npy_longlong longlong_t
+ */
+typedef npy_long __pyx_t_5numpy_int_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":801
+ * # numpy.int corresponds to 'l' and numpy.long to 'q'
+ * ctypedef npy_long int_t
+ * ctypedef npy_longlong long_t # <<<<<<<<<<<<<<
+ * ctypedef npy_longlong longlong_t
+ *
+ */
+typedef npy_longlong __pyx_t_5numpy_long_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":802
+ * ctypedef npy_long int_t
+ * ctypedef npy_longlong long_t
+ * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<<
+ *
+ * ctypedef npy_ulong uint_t
+ */
+typedef npy_longlong __pyx_t_5numpy_longlong_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":804
+ * ctypedef npy_longlong longlong_t
+ *
+ * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<<
+ * ctypedef npy_ulonglong ulong_t
+ * ctypedef npy_ulonglong ulonglong_t
+ */
+typedef npy_ulong __pyx_t_5numpy_uint_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":805
+ *
+ * ctypedef npy_ulong uint_t
+ * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<<
+ * ctypedef npy_ulonglong ulonglong_t
+ *
+ */
+typedef npy_ulonglong __pyx_t_5numpy_ulong_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":806
+ * ctypedef npy_ulong uint_t
+ * ctypedef npy_ulonglong ulong_t
+ * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<<
+ *
+ * ctypedef npy_intp intp_t
+ */
+typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":808
+ * ctypedef npy_ulonglong ulonglong_t
+ *
+ * ctypedef npy_intp intp_t # <<<<<<<<<<<<<<
+ * ctypedef npy_uintp uintp_t
+ *
+ */
+typedef npy_intp __pyx_t_5numpy_intp_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":809
+ *
+ * ctypedef npy_intp intp_t
+ * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<<
+ *
+ * ctypedef npy_double float_t
+ */
+typedef npy_uintp __pyx_t_5numpy_uintp_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":811
+ * ctypedef npy_uintp uintp_t
+ *
+ * ctypedef npy_double float_t # <<<<<<<<<<<<<<
+ * ctypedef npy_double double_t
+ * ctypedef npy_longdouble longdouble_t
+ */
+typedef npy_double __pyx_t_5numpy_float_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":812
+ *
+ * ctypedef npy_double float_t
+ * ctypedef npy_double double_t # <<<<<<<<<<<<<<
+ * ctypedef npy_longdouble longdouble_t
+ *
+ */
+typedef npy_double __pyx_t_5numpy_double_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":813
+ * ctypedef npy_double float_t
+ * ctypedef npy_double double_t
+ * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<<
+ *
+ * ctypedef npy_cfloat cfloat_t
+ */
+typedef npy_longdouble __pyx_t_5numpy_longdouble_t;
+/* Declarations.proto */
+#if CYTHON_CCOMPLEX
+ #ifdef __cplusplus
+ typedef ::std::complex< float > __pyx_t_float_complex;
+ #else
+ typedef float _Complex __pyx_t_float_complex;
+ #endif
+#else
+ typedef struct { float real, imag; } __pyx_t_float_complex;
+#endif
+static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float);
+
+/* Declarations.proto */
+#if CYTHON_CCOMPLEX
+ #ifdef __cplusplus
+ typedef ::std::complex< double > __pyx_t_double_complex;
+ #else
+ typedef double _Complex __pyx_t_double_complex;
+ #endif
+#else
+ typedef struct { double real, imag; } __pyx_t_double_complex;
+#endif
+static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double);
+
+
+/*--- Type declarations ---*/
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":815
+ * ctypedef npy_longdouble longdouble_t
+ *
+ * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<<
+ * ctypedef npy_cdouble cdouble_t
+ * ctypedef npy_clongdouble clongdouble_t
+ */
+typedef npy_cfloat __pyx_t_5numpy_cfloat_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":816
+ *
+ * ctypedef npy_cfloat cfloat_t
+ * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<<
+ * ctypedef npy_clongdouble clongdouble_t
+ *
+ */
+typedef npy_cdouble __pyx_t_5numpy_cdouble_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":817
+ * ctypedef npy_cfloat cfloat_t
+ * ctypedef npy_cdouble cdouble_t
+ * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<<
+ *
+ * ctypedef npy_cdouble complex_t
+ */
+typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t;
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":819
+ * ctypedef npy_clongdouble clongdouble_t
+ *
+ * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<<
+ *
+ * cdef inline object PyArray_MultiIterNew1(a):
+ */
+typedef npy_cdouble __pyx_t_5numpy_complex_t;
+
+/* --- Runtime support code (head) --- */
+/* Refnanny.proto */
+#ifndef CYTHON_REFNANNY
+ #define CYTHON_REFNANNY 0
+#endif
+#if CYTHON_REFNANNY
+ typedef struct {
+ void (*INCREF)(void*, PyObject*, int);
+ void (*DECREF)(void*, PyObject*, int);
+ void (*GOTREF)(void*, PyObject*, int);
+ void (*GIVEREF)(void*, PyObject*, int);
+ void* (*SetupContext)(const char*, int, const char*);
+ void (*FinishContext)(void**);
+ } __Pyx_RefNannyAPIStruct;
+ static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
+ static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
+ #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
+#ifdef WITH_THREAD
+ #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+ if (acquire_gil) {\
+ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
+ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+ PyGILState_Release(__pyx_gilstate_save);\
+ } else {\
+ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
+ }
+#else
+ #define __Pyx_RefNannySetupContext(name, acquire_gil)\
+ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
+#endif
+ #define __Pyx_RefNannyFinishContext()\
+ __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
+ #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+ #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+ #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+ #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
+ #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
+ #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
+ #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
+ #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
+#else
+ #define __Pyx_RefNannyDeclarations
+ #define __Pyx_RefNannySetupContext(name, acquire_gil)
+ #define __Pyx_RefNannyFinishContext()
+ #define __Pyx_INCREF(r) Py_INCREF(r)
+ #define __Pyx_DECREF(r) Py_DECREF(r)
+ #define __Pyx_GOTREF(r)
+ #define __Pyx_GIVEREF(r)
+ #define __Pyx_XINCREF(r) Py_XINCREF(r)
+ #define __Pyx_XDECREF(r) Py_XDECREF(r)
+ #define __Pyx_XGOTREF(r)
+ #define __Pyx_XGIVEREF(r)
+#endif
+#define __Pyx_XDECREF_SET(r, v) do {\
+ PyObject *tmp = (PyObject *) r;\
+ r = v; __Pyx_XDECREF(tmp);\
+ } while (0)
+#define __Pyx_DECREF_SET(r, v) do {\
+ PyObject *tmp = (PyObject *) r;\
+ r = v; __Pyx_DECREF(tmp);\
+ } while (0)
+#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
+#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
+
+/* PyObjectGetAttrStr.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
+#else
+#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
+#endif
+
+/* GetBuiltinName.proto */
+static PyObject *__Pyx_GetBuiltinName(PyObject *name);
+
+/* RaiseArgTupleInvalid.proto */
+static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
+ Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
+
+/* RaiseDoubleKeywords.proto */
+static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
+
+/* ParseKeywords.proto */
+static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
+ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
+ const char* function_name);
+
+/* ArgTypeTest.proto */
+#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\
+ ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\
+ __Pyx__ArgTypeTest(obj, type, name, exact))
+static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact);
+
+/* IsLittleEndian.proto */
+static CYTHON_INLINE int __Pyx_Is_Little_Endian(void);
+
+/* BufferFormatCheck.proto */
+static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts);
+static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
+ __Pyx_BufFmt_StackElem* stack,
+ __Pyx_TypeInfo* type);
+
+/* BufferGetAndValidate.proto */
+#define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\
+ ((obj == Py_None || obj == NULL) ?\
+ (__Pyx_ZeroBuffer(buf), 0) :\
+ __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack))
+static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj,
+ __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack);
+static void __Pyx_ZeroBuffer(Py_buffer* buf);
+static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info);
+static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 };
+static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+
+/* GetItemInt.proto */
+#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+ __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\
+ (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\
+ __Pyx_GetItemInt_Generic(o, to_py_func(i))))
+#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+ __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
+ (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL))
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
+ int wraparound, int boundscheck);
+#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
+ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
+ __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
+ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL))
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
+ int wraparound, int boundscheck);
+static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j);
+static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
+ int is_list, int wraparound, int boundscheck);
+
+/* ObjectGetItem.proto */
+#if CYTHON_USE_TYPE_SLOTS
+static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key);
+#else
+#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key)
+#endif
+
+/* ExtTypeTest.proto */
+static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);
+
+/* PyIntBinop.proto */
+#if !CYTHON_COMPILING_IN_PYPY
+static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check);
+#else
+#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\
+ (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2))
+#endif
+
+/* PyFunctionFastCall.proto */
+#if CYTHON_FAST_PYCALL
+#define __Pyx_PyFunction_FastCall(func, args, nargs)\
+ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
+#if 1 || PY_VERSION_HEX < 0x030600B1
+static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs);
+#else
+#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs)
+#endif
+#define __Pyx_BUILD_ASSERT_EXPR(cond)\
+ (sizeof(char [1 - 2*!(cond)]) - 1)
+#ifndef Py_MEMBER_SIZE
+#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
+#endif
+ static size_t __pyx_pyframe_localsplus_offset = 0;
+ #include "frameobject.h"
+ #define __Pxy_PyFrame_Initialize_Offsets()\
+ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\
+ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus)))
+ #define __Pyx_PyFrame_GetLocalsplus(frame)\
+ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset))
+#endif
+
+/* PyObjectCall.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
+#else
+#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
+#endif
+
+/* PyObjectCallMethO.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
+#endif
+
+/* PyObjectCallNoArg.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
+#else
+#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL)
+#endif
+
+/* PyCFunctionFastCall.proto */
+#if CYTHON_FAST_PYCCALL
+static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs);
+#else
+#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL)
+#endif
+
+/* PyObjectCallOneArg.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
+
+/* PyDictVersioning.proto */
+#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS
+#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1)
+#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag)
+#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\
+ (version_var) = __PYX_GET_DICT_VERSION(dict);\
+ (cache_var) = (value);
+#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\
+ static PY_UINT64_T __pyx_dict_version = 0;\
+ static PyObject *__pyx_dict_cached_value = NULL;\
+ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\
+ (VAR) = __pyx_dict_cached_value;\
+ } else {\
+ (VAR) = __pyx_dict_cached_value = (LOOKUP);\
+ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\
+ }\
+}
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj);
+static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj);
+static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version);
+#else
+#define __PYX_GET_DICT_VERSION(dict) (0)
+#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)
+#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP);
+#endif
+
+/* GetModuleGlobalName.proto */
+#if CYTHON_USE_DICT_VERSIONS
+#define __Pyx_GetModuleGlobalName(var, name) {\
+ static PY_UINT64_T __pyx_dict_version = 0;\
+ static PyObject *__pyx_dict_cached_value = NULL;\
+ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\
+ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\
+ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
+}
+#define __Pyx_GetModuleGlobalNameUncached(var, name) {\
+ PY_UINT64_T __pyx_dict_version;\
+ PyObject *__pyx_dict_cached_value;\
+ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\
+}
+static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value);
+#else
+#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name)
+#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name)
+static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name);
+#endif
+
+/* BufferIndexError.proto */
+static void __Pyx_RaiseBufferIndexError(int axis);
+
+#define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0)
+/* ListAppend.proto */
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
+ PyListObject* L = (PyListObject*) list;
+ Py_ssize_t len = Py_SIZE(list);
+ if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) {
+ Py_INCREF(x);
+ PyList_SET_ITEM(list, len, x);
+ Py_SIZE(list) = len+1;
+ return 0;
+ }
+ return PyList_Append(list, x);
+}
+#else
+#define __Pyx_PyList_Append(L,x) PyList_Append(L,x)
+#endif
+
+/* PyThreadStateGet.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate;
+#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current;
+#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type
+#else
+#define __Pyx_PyThreadState_declare
+#define __Pyx_PyThreadState_assign
+#define __Pyx_PyErr_Occurred() PyErr_Occurred()
+#endif
+
+/* PyErrFetchRestore.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
+#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
+#else
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#endif
+#else
+#define __Pyx_PyErr_Clear() PyErr_Clear()
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb)
+#endif
+
+#define __Pyx_BufPtrStrided2d(type, buf, i0, s0, i1, s1) (type)((char*)buf + i0 * s0 + i1 * s1)
+/* PyObjectCall2Args.proto */
+static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2);
+
+/* ListCompAppend.proto */
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
+ PyListObject* L = (PyListObject*) list;
+ Py_ssize_t len = Py_SIZE(list);
+ if (likely(L->allocated > len)) {
+ Py_INCREF(x);
+ PyList_SET_ITEM(list, len, x);
+ Py_SIZE(list) = len+1;
+ return 0;
+ }
+ return PyList_Append(list, x);
+}
+#else
+#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
+#endif
+
+/* RaiseException.proto */
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
+
+/* DictGetItem.proto */
+#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
+static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key);
+#define __Pyx_PyObject_Dict_GetItem(obj, name)\
+ (likely(PyDict_CheckExact(obj)) ?\
+ __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name))
+#else
+#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key)
+#define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name)
+#endif
+
+/* RaiseTooManyValuesToUnpack.proto */
+static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);
+
+/* RaiseNeedMoreValuesToUnpack.proto */
+static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);
+
+/* RaiseNoneIterError.proto */
+static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
+
+/* GetTopmostException.proto */
+#if CYTHON_USE_EXC_INFO_STACK
+static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
+#endif
+
+/* SaveResetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
+#else
+#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb)
+#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb)
+#endif
+
+/* PyErrExceptionMatches.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
+#else
+#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err)
+#endif
+
+/* GetException.proto */
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb)
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);
+#endif
+
+/* TypeImport.proto */
+#ifndef __PYX_HAVE_RT_ImportType_proto
+#define __PYX_HAVE_RT_ImportType_proto
+enum __Pyx_ImportType_CheckSize {
+ __Pyx_ImportType_CheckSize_Error = 0,
+ __Pyx_ImportType_CheckSize_Warn = 1,
+ __Pyx_ImportType_CheckSize_Ignore = 2
+};
+static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size);
+#endif
+
+/* Import.proto */
+static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
+
+/* CLineInTraceback.proto */
+#ifdef CYTHON_CLINE_IN_TRACEBACK
+#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
+#else
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
+#endif
+
+/* CodeObjectCache.proto */
+typedef struct {
+ PyCodeObject* code_object;
+ int code_line;
+} __Pyx_CodeObjectCacheEntry;
+struct __Pyx_CodeObjectCache {
+ int count;
+ int max_count;
+ __Pyx_CodeObjectCacheEntry* entries;
+};
+static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
+static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
+static PyCodeObject *__pyx_find_code_object(int code_line);
+static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
+
+/* AddTraceback.proto */
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+ int py_line, const char *filename);
+
+/* BufferStructDeclare.proto */
+typedef struct {
+ Py_ssize_t shape, strides, suboffsets;
+} __Pyx_Buf_DimInfo;
+typedef struct {
+ size_t refcount;
+ Py_buffer pybuffer;
+} __Pyx_Buffer;
+typedef struct {
+ __Pyx_Buffer *rcbuffer;
+ char *data;
+ __Pyx_Buf_DimInfo diminfo[8];
+} __Pyx_LocalBuf_ND;
+
+#if PY_MAJOR_VERSION < 3
+ static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags);
+ static void __Pyx_ReleaseBuffer(Py_buffer *view);
+#else
+ #define __Pyx_GetBuffer PyObject_GetBuffer
+ #define __Pyx_ReleaseBuffer PyBuffer_Release
+#endif
+
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value);
+
+/* RealImag.proto */
+#if CYTHON_CCOMPLEX
+ #ifdef __cplusplus
+ #define __Pyx_CREAL(z) ((z).real())
+ #define __Pyx_CIMAG(z) ((z).imag())
+ #else
+ #define __Pyx_CREAL(z) (__real__(z))
+ #define __Pyx_CIMAG(z) (__imag__(z))
+ #endif
+#else
+ #define __Pyx_CREAL(z) ((z).real)
+ #define __Pyx_CIMAG(z) ((z).imag)
+#endif
+#if defined(__cplusplus) && CYTHON_CCOMPLEX\
+ && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103)
+ #define __Pyx_SET_CREAL(z,x) ((z).real(x))
+ #define __Pyx_SET_CIMAG(z,y) ((z).imag(y))
+#else
+ #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x)
+ #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y)
+#endif
+
+/* Arithmetic.proto */
+#if CYTHON_CCOMPLEX
+ #define __Pyx_c_eq_float(a, b) ((a)==(b))
+ #define __Pyx_c_sum_float(a, b) ((a)+(b))
+ #define __Pyx_c_diff_float(a, b) ((a)-(b))
+ #define __Pyx_c_prod_float(a, b) ((a)*(b))
+ #define __Pyx_c_quot_float(a, b) ((a)/(b))
+ #define __Pyx_c_neg_float(a) (-(a))
+ #ifdef __cplusplus
+ #define __Pyx_c_is_zero_float(z) ((z)==(float)0)
+ #define __Pyx_c_conj_float(z) (::std::conj(z))
+ #if 1
+ #define __Pyx_c_abs_float(z) (::std::abs(z))
+ #define __Pyx_c_pow_float(a, b) (::std::pow(a, b))
+ #endif
+ #else
+ #define __Pyx_c_is_zero_float(z) ((z)==0)
+ #define __Pyx_c_conj_float(z) (conjf(z))
+ #if 1
+ #define __Pyx_c_abs_float(z) (cabsf(z))
+ #define __Pyx_c_pow_float(a, b) (cpowf(a, b))
+ #endif
+ #endif
+#else
+ static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex);
+ static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex);
+ static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex);
+ static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex);
+ static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex);
+ static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex);
+ static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex);
+ static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex);
+ #if 1
+ static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex);
+ static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex);
+ #endif
+#endif
+
+/* Arithmetic.proto */
+#if CYTHON_CCOMPLEX
+ #define __Pyx_c_eq_double(a, b) ((a)==(b))
+ #define __Pyx_c_sum_double(a, b) ((a)+(b))
+ #define __Pyx_c_diff_double(a, b) ((a)-(b))
+ #define __Pyx_c_prod_double(a, b) ((a)*(b))
+ #define __Pyx_c_quot_double(a, b) ((a)/(b))
+ #define __Pyx_c_neg_double(a) (-(a))
+ #ifdef __cplusplus
+ #define __Pyx_c_is_zero_double(z) ((z)==(double)0)
+ #define __Pyx_c_conj_double(z) (::std::conj(z))
+ #if 1
+ #define __Pyx_c_abs_double(z) (::std::abs(z))
+ #define __Pyx_c_pow_double(a, b) (::std::pow(a, b))
+ #endif
+ #else
+ #define __Pyx_c_is_zero_double(z) ((z)==0)
+ #define __Pyx_c_conj_double(z) (conj(z))
+ #if 1
+ #define __Pyx_c_abs_double(z) (cabs(z))
+ #define __Pyx_c_pow_double(a, b) (cpow(a, b))
+ #endif
+ #endif
+#else
+ static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex);
+ static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex);
+ static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex);
+ static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex);
+ static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex);
+ static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex);
+ static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex);
+ static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex);
+ #if 1
+ static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex);
+ static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex);
+ #endif
+#endif
+
+/* CIntToPy.proto */
+static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
+
+/* CIntFromPy.proto */
+static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
+
+/* FastTypeChecks.proto */
+#if CYTHON_COMPILING_IN_CPYTHON
+#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
+static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
+static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
+static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
+#else
+#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
+#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
+#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
+#endif
+#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
+
+/* CheckBinaryVersion.proto */
+static int __Pyx_check_binary_version(void);
+
+/* InitStrings.proto */
+static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
+
+
+/* Module declarations from 'cpython.buffer' */
+
+/* Module declarations from 'libc.string' */
+
+/* Module declarations from 'libc.stdio' */
+
+/* Module declarations from '__builtin__' */
+
+/* Module declarations from 'cpython.type' */
+static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0;
+
+/* Module declarations from 'cpython' */
+
+/* Module declarations from 'cpython.object' */
+
+/* Module declarations from 'cpython.ref' */
+
+/* Module declarations from 'cpython.mem' */
+
+/* Module declarations from 'numpy' */
+
+/* Module declarations from 'numpy' */
+static PyTypeObject *__pyx_ptype_5numpy_dtype = 0;
+static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0;
+static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0;
+static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0;
+static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0;
+static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/
+
+/* Module declarations from 'nms' */
+static CYTHON_INLINE __pyx_t_5numpy_float32_t __pyx_f_3nms_max(__pyx_t_5numpy_float32_t, __pyx_t_5numpy_float32_t); /*proto*/
+static CYTHON_INLINE __pyx_t_5numpy_float32_t __pyx_f_3nms_min(__pyx_t_5numpy_float32_t, __pyx_t_5numpy_float32_t); /*proto*/
+static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t = { "float32_t", NULL, sizeof(__pyx_t_5numpy_float32_t), { 0 }, 0, 'R', 0, 0 };
+static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_int_t = { "int_t", NULL, sizeof(__pyx_t_5numpy_int_t), { 0 }, 0, IS_UNSIGNED(__pyx_t_5numpy_int_t) ? 'U' : 'I', IS_UNSIGNED(__pyx_t_5numpy_int_t), 0 };
+static __Pyx_TypeInfo __Pyx_TypeInfo_float = { "float", NULL, sizeof(float), { 0 }, 0, 'R', 0, 0 };
+#define __Pyx_MODULE_NAME "nms"
+extern int __pyx_module_is_main_nms;
+int __pyx_module_is_main_nms = 0;
+
+/* Implementation of 'nms' */
+static PyObject *__pyx_builtin_range;
+static PyObject *__pyx_builtin_ValueError;
+static PyObject *__pyx_builtin_RuntimeError;
+static PyObject *__pyx_builtin_ImportError;
+static const char __pyx_k_N[] = "N";
+static const char __pyx_k_h[] = "h";
+static const char __pyx_k_i[] = "_i";
+static const char __pyx_k_j[] = "_j";
+static const char __pyx_k_s[] = "s";
+static const char __pyx_k_w[] = "w";
+static const char __pyx_k_Nt[] = "Nt";
+static const char __pyx_k_ih[] = "ih";
+static const char __pyx_k_iw[] = "iw";
+static const char __pyx_k_mw[] = "mw";
+static const char __pyx_k_np[] = "np";
+static const char __pyx_k_ov[] = "ov";
+static const char __pyx_k_ts[] = "ts";
+static const char __pyx_k_ua[] = "ua";
+static const char __pyx_k_x1[] = "x1";
+static const char __pyx_k_x2[] = "x2";
+static const char __pyx_k_y1[] = "y1";
+static const char __pyx_k_y2[] = "y2";
+static const char __pyx_k_exp[] = "exp";
+static const char __pyx_k_i_2[] = "i";
+static const char __pyx_k_int[] = "int";
+static const char __pyx_k_ix1[] = "ix1";
+static const char __pyx_k_ix2[] = "ix2";
+static const char __pyx_k_iy1[] = "iy1";
+static const char __pyx_k_iy2[] = "iy2";
+static const char __pyx_k_j_2[] = "j";
+static const char __pyx_k_mbs[] = "mbs";
+static const char __pyx_k_mts[] = "mts";
+static const char __pyx_k_mx1[] = "mx1";
+static const char __pyx_k_mx2[] = "mx2";
+static const char __pyx_k_my1[] = "my1";
+static const char __pyx_k_my2[] = "my2";
+static const char __pyx_k_nms[] = "nms";
+static const char __pyx_k_ovr[] = "ovr";
+static const char __pyx_k_pos[] = "pos";
+static const char __pyx_k_tmp[] = "tmp";
+static const char __pyx_k_tx1[] = "tx1";
+static const char __pyx_k_tx2[] = "tx2";
+static const char __pyx_k_ty1[] = "ty1";
+static const char __pyx_k_ty2[] = "ty2";
+static const char __pyx_k_xx1[] = "xx1";
+static const char __pyx_k_xx2[] = "xx2";
+static const char __pyx_k_yy1[] = "yy1";
+static const char __pyx_k_yy2[] = "yy2";
+static const char __pyx_k_area[] = "area";
+static const char __pyx_k_dets[] = "dets";
+static const char __pyx_k_keep[] = "keep";
+static const char __pyx_k_main[] = "__main__";
+static const char __pyx_k_name[] = "__name__";
+static const char __pyx_k_test[] = "__test__";
+static const char __pyx_k_areas[] = "areas";
+static const char __pyx_k_boxes[] = "boxes";
+static const char __pyx_k_dtype[] = "dtype";
+static const char __pyx_k_iarea[] = "iarea";
+static const char __pyx_k_inter[] = "inter";
+static const char __pyx_k_ndets[] = "ndets";
+static const char __pyx_k_numpy[] = "numpy";
+static const char __pyx_k_order[] = "order";
+static const char __pyx_k_range[] = "range";
+static const char __pyx_k_sigma[] = "sigma";
+static const char __pyx_k_zeros[] = "zeros";
+static const char __pyx_k_import[] = "__import__";
+static const char __pyx_k_maxpos[] = "maxpos";
+static const char __pyx_k_method[] = "method";
+static const char __pyx_k_scores[] = "scores";
+static const char __pyx_k_thresh[] = "thresh";
+static const char __pyx_k_weight[] = "weight";
+static const char __pyx_k_argsort[] = "argsort";
+static const char __pyx_k_nms_pyx[] = "nms.pyx";
+static const char __pyx_k_box_area[] = "box_area";
+static const char __pyx_k_maxscore[] = "maxscore";
+static const char __pyx_k_soft_nms[] = "soft_nms";
+static const char __pyx_k_threshold[] = "threshold";
+static const char __pyx_k_ValueError[] = "ValueError";
+static const char __pyx_k_suppressed[] = "suppressed";
+static const char __pyx_k_weight_exp[] = "weight_exp";
+static const char __pyx_k_ImportError[] = "ImportError";
+static const char __pyx_k_soft_nms_39[] = "soft_nms_39";
+static const char __pyx_k_RuntimeError[] = "RuntimeError";
+static const char __pyx_k_soft_nms_merge[] = "soft_nms_merge";
+static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
+static const char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous";
+static const char __pyx_k_numpy_core_multiarray_failed_to[] = "numpy.core.multiarray failed to import";
+static const char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)";
+static const char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd";
+static const char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported";
+static const char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous";
+static const char __pyx_k_numpy_core_umath_failed_to_impor[] = "numpy.core.umath failed to import";
+static const char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short.";
+static PyObject *__pyx_kp_u_Format_string_allocated_too_shor;
+static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2;
+static PyObject *__pyx_n_s_ImportError;
+static PyObject *__pyx_n_s_N;
+static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor;
+static PyObject *__pyx_n_s_Nt;
+static PyObject *__pyx_n_s_RuntimeError;
+static PyObject *__pyx_n_s_ValueError;
+static PyObject *__pyx_n_s_area;
+static PyObject *__pyx_n_s_areas;
+static PyObject *__pyx_n_s_argsort;
+static PyObject *__pyx_n_s_box_area;
+static PyObject *__pyx_n_s_boxes;
+static PyObject *__pyx_n_s_cline_in_traceback;
+static PyObject *__pyx_n_s_dets;
+static PyObject *__pyx_n_s_dtype;
+static PyObject *__pyx_n_s_exp;
+static PyObject *__pyx_n_s_h;
+static PyObject *__pyx_n_s_i;
+static PyObject *__pyx_n_s_i_2;
+static PyObject *__pyx_n_s_iarea;
+static PyObject *__pyx_n_s_ih;
+static PyObject *__pyx_n_s_import;
+static PyObject *__pyx_n_s_int;
+static PyObject *__pyx_n_s_inter;
+static PyObject *__pyx_n_s_iw;
+static PyObject *__pyx_n_s_ix1;
+static PyObject *__pyx_n_s_ix2;
+static PyObject *__pyx_n_s_iy1;
+static PyObject *__pyx_n_s_iy2;
+static PyObject *__pyx_n_s_j;
+static PyObject *__pyx_n_s_j_2;
+static PyObject *__pyx_n_s_keep;
+static PyObject *__pyx_n_s_main;
+static PyObject *__pyx_n_s_maxpos;
+static PyObject *__pyx_n_s_maxscore;
+static PyObject *__pyx_n_s_mbs;
+static PyObject *__pyx_n_s_method;
+static PyObject *__pyx_n_s_mts;
+static PyObject *__pyx_n_s_mw;
+static PyObject *__pyx_n_s_mx1;
+static PyObject *__pyx_n_s_mx2;
+static PyObject *__pyx_n_s_my1;
+static PyObject *__pyx_n_s_my2;
+static PyObject *__pyx_n_s_name;
+static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous;
+static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou;
+static PyObject *__pyx_n_s_ndets;
+static PyObject *__pyx_n_s_nms;
+static PyObject *__pyx_kp_s_nms_pyx;
+static PyObject *__pyx_n_s_np;
+static PyObject *__pyx_n_s_numpy;
+static PyObject *__pyx_kp_s_numpy_core_multiarray_failed_to;
+static PyObject *__pyx_kp_s_numpy_core_umath_failed_to_impor;
+static PyObject *__pyx_n_s_order;
+static PyObject *__pyx_n_s_ov;
+static PyObject *__pyx_n_s_ovr;
+static PyObject *__pyx_n_s_pos;
+static PyObject *__pyx_n_s_range;
+static PyObject *__pyx_n_s_s;
+static PyObject *__pyx_n_s_scores;
+static PyObject *__pyx_n_s_sigma;
+static PyObject *__pyx_n_s_soft_nms;
+static PyObject *__pyx_n_s_soft_nms_39;
+static PyObject *__pyx_n_s_soft_nms_merge;
+static PyObject *__pyx_n_s_suppressed;
+static PyObject *__pyx_n_s_test;
+static PyObject *__pyx_n_s_thresh;
+static PyObject *__pyx_n_s_threshold;
+static PyObject *__pyx_n_s_tmp;
+static PyObject *__pyx_n_s_ts;
+static PyObject *__pyx_n_s_tx1;
+static PyObject *__pyx_n_s_tx2;
+static PyObject *__pyx_n_s_ty1;
+static PyObject *__pyx_n_s_ty2;
+static PyObject *__pyx_n_s_ua;
+static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd;
+static PyObject *__pyx_n_s_w;
+static PyObject *__pyx_n_s_weight;
+static PyObject *__pyx_n_s_weight_exp;
+static PyObject *__pyx_n_s_x1;
+static PyObject *__pyx_n_s_x2;
+static PyObject *__pyx_n_s_xx1;
+static PyObject *__pyx_n_s_xx2;
+static PyObject *__pyx_n_s_y1;
+static PyObject *__pyx_n_s_y2;
+static PyObject *__pyx_n_s_yy1;
+static PyObject *__pyx_n_s_yy2;
+static PyObject *__pyx_n_s_zeros;
+static PyObject *__pyx_pf_3nms_nms(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_dets, PyObject *__pyx_v_thresh); /* proto */
+static PyObject *__pyx_pf_3nms_2soft_nms(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, float __pyx_v_sigma, float __pyx_v_Nt, float __pyx_v_threshold, unsigned int __pyx_v_method); /* proto */
+static PyObject *__pyx_pf_3nms_4soft_nms_39(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, float __pyx_v_sigma, float __pyx_v_Nt, float __pyx_v_threshold, unsigned int __pyx_v_method); /* proto */
+static PyObject *__pyx_pf_3nms_6soft_nms_merge(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, float __pyx_v_sigma, float __pyx_v_Nt, float __pyx_v_threshold, unsigned int __pyx_v_method, float __pyx_v_weight_exp); /* proto */
+static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */
+static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */
+static PyObject *__pyx_int_0;
+static PyObject *__pyx_int_1;
+static PyObject *__pyx_int_2;
+static PyObject *__pyx_int_3;
+static PyObject *__pyx_int_4;
+static PyObject *__pyx_int_5;
+static PyObject *__pyx_int_6;
+static PyObject *__pyx_int_neg_1;
+static PyObject *__pyx_slice_;
+static PyObject *__pyx_slice__7;
+static PyObject *__pyx_tuple__2;
+static PyObject *__pyx_tuple__3;
+static PyObject *__pyx_tuple__4;
+static PyObject *__pyx_tuple__5;
+static PyObject *__pyx_tuple__6;
+static PyObject *__pyx_tuple__8;
+static PyObject *__pyx_tuple__9;
+static PyObject *__pyx_tuple__10;
+static PyObject *__pyx_tuple__11;
+static PyObject *__pyx_tuple__12;
+static PyObject *__pyx_tuple__13;
+static PyObject *__pyx_tuple__14;
+static PyObject *__pyx_tuple__15;
+static PyObject *__pyx_tuple__17;
+static PyObject *__pyx_tuple__19;
+static PyObject *__pyx_tuple__21;
+static PyObject *__pyx_codeobj__16;
+static PyObject *__pyx_codeobj__18;
+static PyObject *__pyx_codeobj__20;
+static PyObject *__pyx_codeobj__22;
+/* Late includes */
+
+/* "nms.pyx":18
+ * cimport numpy as np
+ *
+ * cdef inline np.float32_t max(np.float32_t a, np.float32_t b): # <<<<<<<<<<<<<<
+ * return a if a >= b else b
+ *
+ */
+
+static CYTHON_INLINE __pyx_t_5numpy_float32_t __pyx_f_3nms_max(__pyx_t_5numpy_float32_t __pyx_v_a, __pyx_t_5numpy_float32_t __pyx_v_b) {
+ __pyx_t_5numpy_float32_t __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __pyx_t_5numpy_float32_t __pyx_t_1;
+ __Pyx_RefNannySetupContext("max", 0);
+
+ /* "nms.pyx":19
+ *
+ * cdef inline np.float32_t max(np.float32_t a, np.float32_t b):
+ * return a if a >= b else b # <<<<<<<<<<<<<<
+ *
+ * cdef inline np.float32_t min(np.float32_t a, np.float32_t b):
+ */
+ if (((__pyx_v_a >= __pyx_v_b) != 0)) {
+ __pyx_t_1 = __pyx_v_a;
+ } else {
+ __pyx_t_1 = __pyx_v_b;
+ }
+ __pyx_r = __pyx_t_1;
+ goto __pyx_L0;
+
+ /* "nms.pyx":18
+ * cimport numpy as np
+ *
+ * cdef inline np.float32_t max(np.float32_t a, np.float32_t b): # <<<<<<<<<<<<<<
+ * return a if a >= b else b
+ *
+ */
+
+ /* function exit code */
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "nms.pyx":21
+ * return a if a >= b else b
+ *
+ * cdef inline np.float32_t min(np.float32_t a, np.float32_t b): # <<<<<<<<<<<<<<
+ * return a if a <= b else b
+ *
+ */
+
+static CYTHON_INLINE __pyx_t_5numpy_float32_t __pyx_f_3nms_min(__pyx_t_5numpy_float32_t __pyx_v_a, __pyx_t_5numpy_float32_t __pyx_v_b) {
+ __pyx_t_5numpy_float32_t __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __pyx_t_5numpy_float32_t __pyx_t_1;
+ __Pyx_RefNannySetupContext("min", 0);
+
+ /* "nms.pyx":22
+ *
+ * cdef inline np.float32_t min(np.float32_t a, np.float32_t b):
+ * return a if a <= b else b # <<<<<<<<<<<<<<
+ *
+ * def nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):
+ */
+ if (((__pyx_v_a <= __pyx_v_b) != 0)) {
+ __pyx_t_1 = __pyx_v_a;
+ } else {
+ __pyx_t_1 = __pyx_v_b;
+ }
+ __pyx_r = __pyx_t_1;
+ goto __pyx_L0;
+
+ /* "nms.pyx":21
+ * return a if a >= b else b
+ *
+ * cdef inline np.float32_t min(np.float32_t a, np.float32_t b): # <<<<<<<<<<<<<<
+ * return a if a <= b else b
+ *
+ */
+
+ /* function exit code */
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "nms.pyx":24
+ * return a if a <= b else b
+ *
+ * def nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh): # <<<<<<<<<<<<<<
+ * cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+ * cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3nms_1nms(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_3nms_1nms = {"nms", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3nms_1nms, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_3nms_1nms(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyArrayObject *__pyx_v_dets = 0;
+ PyObject *__pyx_v_thresh = 0;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("nms (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dets,&__pyx_n_s_thresh,0};
+ PyObject* values[2] = {0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ CYTHON_FALLTHROUGH;
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ CYTHON_FALLTHROUGH;
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dets)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ CYTHON_FALLTHROUGH;
+ case 1:
+ if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_thresh)) != 0)) kw_args--;
+ else {
+ __Pyx_RaiseArgtupleInvalid("nms", 1, 2, 2, 1); __PYX_ERR(0, 24, __pyx_L3_error)
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "nms") < 0)) __PYX_ERR(0, 24, __pyx_L3_error)
+ }
+ } else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
+ goto __pyx_L5_argtuple_error;
+ } else {
+ values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ }
+ __pyx_v_dets = ((PyArrayObject *)values[0]);
+ __pyx_v_thresh = ((PyObject*)values[1]);
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("nms", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 24, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("nms.nms", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dets), __pyx_ptype_5numpy_ndarray, 1, "dets", 0))) __PYX_ERR(0, 24, __pyx_L1_error)
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_thresh), (&PyFloat_Type), 1, "thresh", 1))) __PYX_ERR(0, 24, __pyx_L1_error)
+ __pyx_r = __pyx_pf_3nms_nms(__pyx_self, __pyx_v_dets, __pyx_v_thresh);
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3nms_nms(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_dets, PyObject *__pyx_v_thresh) {
+ PyArrayObject *__pyx_v_x1 = 0;
+ PyArrayObject *__pyx_v_y1 = 0;
+ PyArrayObject *__pyx_v_x2 = 0;
+ PyArrayObject *__pyx_v_y2 = 0;
+ PyArrayObject *__pyx_v_scores = 0;
+ PyArrayObject *__pyx_v_areas = 0;
+ PyArrayObject *__pyx_v_order = 0;
+ int __pyx_v_ndets;
+ PyArrayObject *__pyx_v_suppressed = 0;
+ int __pyx_v__i;
+ int __pyx_v__j;
+ int __pyx_v_i;
+ int __pyx_v_j;
+ __pyx_t_5numpy_float32_t __pyx_v_ix1;
+ __pyx_t_5numpy_float32_t __pyx_v_iy1;
+ __pyx_t_5numpy_float32_t __pyx_v_ix2;
+ __pyx_t_5numpy_float32_t __pyx_v_iy2;
+ __pyx_t_5numpy_float32_t __pyx_v_iarea;
+ __pyx_t_5numpy_float32_t __pyx_v_xx1;
+ __pyx_t_5numpy_float32_t __pyx_v_yy1;
+ __pyx_t_5numpy_float32_t __pyx_v_xx2;
+ __pyx_t_5numpy_float32_t __pyx_v_yy2;
+ __pyx_t_5numpy_float32_t __pyx_v_w;
+ __pyx_t_5numpy_float32_t __pyx_v_h;
+ __pyx_t_5numpy_float32_t __pyx_v_inter;
+ __pyx_t_5numpy_float32_t __pyx_v_ovr;
+ PyObject *__pyx_v_keep = NULL;
+ __Pyx_LocalBuf_ND __pyx_pybuffernd_areas;
+ __Pyx_Buffer __pyx_pybuffer_areas;
+ __Pyx_LocalBuf_ND __pyx_pybuffernd_dets;
+ __Pyx_Buffer __pyx_pybuffer_dets;
+ __Pyx_LocalBuf_ND __pyx_pybuffernd_order;
+ __Pyx_Buffer __pyx_pybuffer_order;
+ __Pyx_LocalBuf_ND __pyx_pybuffernd_scores;
+ __Pyx_Buffer __pyx_pybuffer_scores;
+ __Pyx_LocalBuf_ND __pyx_pybuffernd_suppressed;
+ __Pyx_Buffer __pyx_pybuffer_suppressed;
+ __Pyx_LocalBuf_ND __pyx_pybuffernd_x1;
+ __Pyx_Buffer __pyx_pybuffer_x1;
+ __Pyx_LocalBuf_ND __pyx_pybuffernd_x2;
+ __Pyx_Buffer __pyx_pybuffer_x2;
+ __Pyx_LocalBuf_ND __pyx_pybuffernd_y1;
+ __Pyx_Buffer __pyx_pybuffer_y1;
+ __Pyx_LocalBuf_ND __pyx_pybuffernd_y2;
+ __Pyx_Buffer __pyx_pybuffer_y2;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyArrayObject *__pyx_t_2 = NULL;
+ PyArrayObject *__pyx_t_3 = NULL;
+ PyArrayObject *__pyx_t_4 = NULL;
+ PyArrayObject *__pyx_t_5 = NULL;
+ PyArrayObject *__pyx_t_6 = NULL;
+ PyObject *__pyx_t_7 = NULL;
+ PyObject *__pyx_t_8 = NULL;
+ PyArrayObject *__pyx_t_9 = NULL;
+ PyArrayObject *__pyx_t_10 = NULL;
+ PyObject *__pyx_t_11 = NULL;
+ PyObject *__pyx_t_12 = NULL;
+ PyArrayObject *__pyx_t_13 = NULL;
+ int __pyx_t_14;
+ int __pyx_t_15;
+ int __pyx_t_16;
+ Py_ssize_t __pyx_t_17;
+ int __pyx_t_18;
+ Py_ssize_t __pyx_t_19;
+ int __pyx_t_20;
+ int __pyx_t_21;
+ Py_ssize_t __pyx_t_22;
+ Py_ssize_t __pyx_t_23;
+ Py_ssize_t __pyx_t_24;
+ Py_ssize_t __pyx_t_25;
+ Py_ssize_t __pyx_t_26;
+ int __pyx_t_27;
+ int __pyx_t_28;
+ Py_ssize_t __pyx_t_29;
+ int __pyx_t_30;
+ Py_ssize_t __pyx_t_31;
+ Py_ssize_t __pyx_t_32;
+ Py_ssize_t __pyx_t_33;
+ Py_ssize_t __pyx_t_34;
+ Py_ssize_t __pyx_t_35;
+ Py_ssize_t __pyx_t_36;
+ __pyx_t_5numpy_float32_t __pyx_t_37;
+ Py_ssize_t __pyx_t_38;
+ __Pyx_RefNannySetupContext("nms", 0);
+ __pyx_pybuffer_x1.pybuffer.buf = NULL;
+ __pyx_pybuffer_x1.refcount = 0;
+ __pyx_pybuffernd_x1.data = NULL;
+ __pyx_pybuffernd_x1.rcbuffer = &__pyx_pybuffer_x1;
+ __pyx_pybuffer_y1.pybuffer.buf = NULL;
+ __pyx_pybuffer_y1.refcount = 0;
+ __pyx_pybuffernd_y1.data = NULL;
+ __pyx_pybuffernd_y1.rcbuffer = &__pyx_pybuffer_y1;
+ __pyx_pybuffer_x2.pybuffer.buf = NULL;
+ __pyx_pybuffer_x2.refcount = 0;
+ __pyx_pybuffernd_x2.data = NULL;
+ __pyx_pybuffernd_x2.rcbuffer = &__pyx_pybuffer_x2;
+ __pyx_pybuffer_y2.pybuffer.buf = NULL;
+ __pyx_pybuffer_y2.refcount = 0;
+ __pyx_pybuffernd_y2.data = NULL;
+ __pyx_pybuffernd_y2.rcbuffer = &__pyx_pybuffer_y2;
+ __pyx_pybuffer_scores.pybuffer.buf = NULL;
+ __pyx_pybuffer_scores.refcount = 0;
+ __pyx_pybuffernd_scores.data = NULL;
+ __pyx_pybuffernd_scores.rcbuffer = &__pyx_pybuffer_scores;
+ __pyx_pybuffer_areas.pybuffer.buf = NULL;
+ __pyx_pybuffer_areas.refcount = 0;
+ __pyx_pybuffernd_areas.data = NULL;
+ __pyx_pybuffernd_areas.rcbuffer = &__pyx_pybuffer_areas;
+ __pyx_pybuffer_order.pybuffer.buf = NULL;
+ __pyx_pybuffer_order.refcount = 0;
+ __pyx_pybuffernd_order.data = NULL;
+ __pyx_pybuffernd_order.rcbuffer = &__pyx_pybuffer_order;
+ __pyx_pybuffer_suppressed.pybuffer.buf = NULL;
+ __pyx_pybuffer_suppressed.refcount = 0;
+ __pyx_pybuffernd_suppressed.data = NULL;
+ __pyx_pybuffernd_suppressed.rcbuffer = &__pyx_pybuffer_suppressed;
+ __pyx_pybuffer_dets.pybuffer.buf = NULL;
+ __pyx_pybuffer_dets.refcount = 0;
+ __pyx_pybuffernd_dets.data = NULL;
+ __pyx_pybuffernd_dets.rcbuffer = &__pyx_pybuffer_dets;
+ {
+ __Pyx_BufFmt_StackElem __pyx_stack[1];
+ if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_dets.rcbuffer->pybuffer, (PyObject*)__pyx_v_dets, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 24, __pyx_L1_error)
+ }
+ __pyx_pybuffernd_dets.diminfo[0].strides = __pyx_pybuffernd_dets.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_dets.diminfo[0].shape = __pyx_pybuffernd_dets.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_dets.diminfo[1].strides = __pyx_pybuffernd_dets.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_dets.diminfo[1].shape = __pyx_pybuffernd_dets.rcbuffer->pybuffer.shape[1];
+
+ /* "nms.pyx":25
+ *
+ * def nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):
+ * cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0] # <<<<<<<<<<<<<<
+ * cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ * cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+ */
+ __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 25, __pyx_L1_error)
+ __pyx_t_2 = ((PyArrayObject *)__pyx_t_1);
+ {
+ __Pyx_BufFmt_StackElem __pyx_stack[1];
+ if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x1.rcbuffer->pybuffer, (PyObject*)__pyx_t_2, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+ __pyx_v_x1 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_x1.rcbuffer->pybuffer.buf = NULL;
+ __PYX_ERR(0, 25, __pyx_L1_error)
+ } else {__pyx_pybuffernd_x1.diminfo[0].strides = __pyx_pybuffernd_x1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x1.diminfo[0].shape = __pyx_pybuffernd_x1.rcbuffer->pybuffer.shape[0];
+ }
+ }
+ __pyx_t_2 = 0;
+ __pyx_v_x1 = ((PyArrayObject *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "nms.pyx":26
+ * def nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh):
+ * cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+ * cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1] # <<<<<<<<<<<<<<
+ * cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+ * cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]
+ */
+ __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 26, __pyx_L1_error)
+ __pyx_t_3 = ((PyArrayObject *)__pyx_t_1);
+ {
+ __Pyx_BufFmt_StackElem __pyx_stack[1];
+ if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_y1.rcbuffer->pybuffer, (PyObject*)__pyx_t_3, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+ __pyx_v_y1 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_y1.rcbuffer->pybuffer.buf = NULL;
+ __PYX_ERR(0, 26, __pyx_L1_error)
+ } else {__pyx_pybuffernd_y1.diminfo[0].strides = __pyx_pybuffernd_y1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_y1.diminfo[0].shape = __pyx_pybuffernd_y1.rcbuffer->pybuffer.shape[0];
+ }
+ }
+ __pyx_t_3 = 0;
+ __pyx_v_y1 = ((PyArrayObject *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "nms.pyx":27
+ * cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+ * cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ * cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2] # <<<<<<<<<<<<<<
+ * cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]
+ * cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]
+ */
+ __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 27, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 27, __pyx_L1_error)
+ __pyx_t_4 = ((PyArrayObject *)__pyx_t_1);
+ {
+ __Pyx_BufFmt_StackElem __pyx_stack[1];
+ if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x2.rcbuffer->pybuffer, (PyObject*)__pyx_t_4, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+ __pyx_v_x2 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_x2.rcbuffer->pybuffer.buf = NULL;
+ __PYX_ERR(0, 27, __pyx_L1_error)
+ } else {__pyx_pybuffernd_x2.diminfo[0].strides = __pyx_pybuffernd_x2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x2.diminfo[0].shape = __pyx_pybuffernd_x2.rcbuffer->pybuffer.shape[0];
+ }
+ }
+ __pyx_t_4 = 0;
+ __pyx_v_x2 = ((PyArrayObject *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "nms.pyx":28
+ * cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ * cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+ * cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3] # <<<<<<<<<<<<<<
+ * cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]
+ *
+ */
+ __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 28, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 28, __pyx_L1_error)
+ __pyx_t_5 = ((PyArrayObject *)__pyx_t_1);
+ {
+ __Pyx_BufFmt_StackElem __pyx_stack[1];
+ if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_y2.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+ __pyx_v_y2 = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_y2.rcbuffer->pybuffer.buf = NULL;
+ __PYX_ERR(0, 28, __pyx_L1_error)
+ } else {__pyx_pybuffernd_y2.diminfo[0].strides = __pyx_pybuffernd_y2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_y2.diminfo[0].shape = __pyx_pybuffernd_y2.rcbuffer->pybuffer.shape[0];
+ }
+ }
+ __pyx_t_5 = 0;
+ __pyx_v_y2 = ((PyArrayObject *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "nms.pyx":29
+ * cdef np.ndarray[np.float32_t, ndim=1] x2 = dets[:, 2]
+ * cdef np.ndarray[np.float32_t, ndim=1] y2 = dets[:, 3]
+ * cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4] # <<<<<<<<<<<<<<
+ *
+ * cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+ */
+ __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_dets), __pyx_tuple__6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 29, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 29, __pyx_L1_error)
+ __pyx_t_6 = ((PyArrayObject *)__pyx_t_1);
+ {
+ __Pyx_BufFmt_StackElem __pyx_stack[1];
+ if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_scores.rcbuffer->pybuffer, (PyObject*)__pyx_t_6, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+ __pyx_v_scores = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_scores.rcbuffer->pybuffer.buf = NULL;
+ __PYX_ERR(0, 29, __pyx_L1_error)
+ } else {__pyx_pybuffernd_scores.diminfo[0].strides = __pyx_pybuffernd_scores.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_scores.diminfo[0].shape = __pyx_pybuffernd_scores.rcbuffer->pybuffer.shape[0];
+ }
+ }
+ __pyx_t_6 = 0;
+ __pyx_v_scores = ((PyArrayObject *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "nms.pyx":31
+ * cdef np.ndarray[np.float32_t, ndim=1] scores = dets[:, 4]
+ *
+ * cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1) # <<<<<<<<<<<<<<
+ * cdef np.ndarray[np.int_t, ndim=1] order = scores.argsort()[::-1]
+ *
+ */
+ __pyx_t_1 = PyNumber_Subtract(((PyObject *)__pyx_v_x2), ((PyObject *)__pyx_v_x1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 31, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_t_1 = PyNumber_Subtract(((PyObject *)__pyx_v_y2), ((PyObject *)__pyx_v_y1)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_8 = __Pyx_PyInt_AddObjC(__pyx_t_1, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 31, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __pyx_t_1 = PyNumber_Multiply(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 31, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 31, __pyx_L1_error)
+ __pyx_t_9 = ((PyArrayObject *)__pyx_t_1);
+ {
+ __Pyx_BufFmt_StackElem __pyx_stack[1];
+ if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_areas.rcbuffer->pybuffer, (PyObject*)__pyx_t_9, &__Pyx_TypeInfo_nn___pyx_t_5numpy_float32_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+ __pyx_v_areas = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_areas.rcbuffer->pybuffer.buf = NULL;
+ __PYX_ERR(0, 31, __pyx_L1_error)
+ } else {__pyx_pybuffernd_areas.diminfo[0].strides = __pyx_pybuffernd_areas.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_areas.diminfo[0].shape = __pyx_pybuffernd_areas.rcbuffer->pybuffer.shape[0];
+ }
+ }
+ __pyx_t_9 = 0;
+ __pyx_v_areas = ((PyArrayObject *)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "nms.pyx":32
+ *
+ * cdef np.ndarray[np.float32_t, ndim=1] areas = (x2 - x1 + 1) * (y2 - y1 + 1)
+ * cdef np.ndarray[np.int_t, ndim=1] order = scores.argsort()[::-1] # <<<<<<<<<<<<<<
+ *
+ * cdef int ndets = dets.shape[0]
+ */
+ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_scores), __pyx_n_s_argsort); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 32, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __pyx_t_7 = NULL;
+ if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
+ __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8);
+ if (likely(__pyx_t_7)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
+ __Pyx_INCREF(__pyx_t_7);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_8, function);
+ }
+ }
+ __pyx_t_1 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_8);
+ __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
+ if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __pyx_t_8 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_slice__7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 32, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ if (!(likely(((__pyx_t_8) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_8, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 32, __pyx_L1_error)
+ __pyx_t_10 = ((PyArrayObject *)__pyx_t_8);
+ {
+ __Pyx_BufFmt_StackElem __pyx_stack[1];
+ if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_order.rcbuffer->pybuffer, (PyObject*)__pyx_t_10, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int_t, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {
+ __pyx_v_order = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_order.rcbuffer->pybuffer.buf = NULL;
+ __PYX_ERR(0, 32, __pyx_L1_error)
+ } else {__pyx_pybuffernd_order.diminfo[0].strides = __pyx_pybuffernd_order.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_order.diminfo[0].shape = __pyx_pybuffernd_order.rcbuffer->pybuffer.shape[0];
+ }
+ }
+ __pyx_t_10 = 0;
+ __pyx_v_order = ((PyArrayObject *)__pyx_t_8);
+ __pyx_t_8 = 0;
+
+ /* "nms.pyx":34
+ * cdef np.ndarray[np.int_t, ndim=1] order = scores.argsort()[::-1]
+ *
+ * cdef int ndets = dets.shape[0] # <<<<<<<<<<<<<<
+ * cdef np.ndarray[np.int_t, ndim=1] suppressed = \
+ * np.zeros((ndets), dtype=np.int)
+ */
+ __pyx_v_ndets = (__pyx_v_dets->dimensions[0]);
+
+ /* "nms.pyx":36
+ * cdef int ndets = dets.shape[0]
+ * cdef np.ndarray[np.int_t, ndim=1] suppressed = \
+ * np.zeros((ndets), dtype=np.int) # <<<<<<<<<<<<<<
+ *
+ * # nominal indices
+ */
+ __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 36, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_n_s_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 36, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_v_ndets); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 36, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 36, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_7);
+ __Pyx_GIVEREF(__pyx_t_8);
+ PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8);
+ __pyx_t_8 = 0;
+ __pyx_t_8 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 36, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_n_s_np); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 36, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_11);
+ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_11, __pyx_n_s_int); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 36, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_12);
+ __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
+ if (PyDict_SetItem(__pyx_t_8, __pyx_n_s_dtype, __pyx_t_12) < 0) __PYX_ERR(0, 36, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+ __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 36, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_12);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ if (!(likely(((__pyx_t_12) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_12, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 36, __pyx_L1_error)
+ __pyx_t_13 = ((PyArrayObject *)__pyx_t_12);
+ {
+ __Pyx_BufFmt_StackElem __pyx_stack[1];
+ if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_suppressed.rcbuffer->pybuffer, (PyObject*)__pyx_t_13, &__Pyx_TypeInfo_nn___pyx_t_5numpy_int_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 1, 0, __pyx_stack) == -1)) {
+ __pyx_v_suppressed = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.buf = NULL;
+ __PYX_ERR(0, 35, __pyx_L1_error)
+ } else {__pyx_pybuffernd_suppressed.diminfo[0].strides = __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_suppressed.diminfo[0].shape = __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.shape[0];
+ }
+ }
+ __pyx_t_13 = 0;
+ __pyx_v_suppressed = ((PyArrayObject *)__pyx_t_12);
+ __pyx_t_12 = 0;
+
+ /* "nms.pyx":49
+ * cdef np.float32_t inter, ovr
+ *
+ * keep = [] # <<<<<<<<<<<<<<
+ * for _i in range(ndets):
+ * i = order[_i]
+ */
+ __pyx_t_12 = PyList_New(0); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 49, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_12);
+ __pyx_v_keep = ((PyObject*)__pyx_t_12);
+ __pyx_t_12 = 0;
+
+ /* "nms.pyx":50
+ *
+ * keep = []
+ * for _i in range(ndets): # <<<<<<<<<<<<<<
+ * i = order[_i]
+ * if suppressed[i] == 1:
+ */
+ __pyx_t_14 = __pyx_v_ndets;
+ __pyx_t_15 = __pyx_t_14;
+ for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_15; __pyx_t_16+=1) {
+ __pyx_v__i = __pyx_t_16;
+
+ /* "nms.pyx":51
+ * keep = []
+ * for _i in range(ndets):
+ * i = order[_i] # <<<<<<<<<<<<<<
+ * if suppressed[i] == 1:
+ * continue
+ */
+ __pyx_t_17 = __pyx_v__i;
+ __pyx_t_18 = -1;
+ if (__pyx_t_17 < 0) {
+ __pyx_t_17 += __pyx_pybuffernd_order.diminfo[0].shape;
+ if (unlikely(__pyx_t_17 < 0)) __pyx_t_18 = 0;
+ } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_order.diminfo[0].shape)) __pyx_t_18 = 0;
+ if (unlikely(__pyx_t_18 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_18);
+ __PYX_ERR(0, 51, __pyx_L1_error)
+ }
+ __pyx_v_i = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_order.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_order.diminfo[0].strides));
+
+ /* "nms.pyx":52
+ * for _i in range(ndets):
+ * i = order[_i]
+ * if suppressed[i] == 1: # <<<<<<<<<<<<<<
+ * continue
+ * keep.append(i)
+ */
+ __pyx_t_19 = __pyx_v_i;
+ __pyx_t_18 = -1;
+ if (__pyx_t_19 < 0) {
+ __pyx_t_19 += __pyx_pybuffernd_suppressed.diminfo[0].shape;
+ if (unlikely(__pyx_t_19 < 0)) __pyx_t_18 = 0;
+ } else if (unlikely(__pyx_t_19 >= __pyx_pybuffernd_suppressed.diminfo[0].shape)) __pyx_t_18 = 0;
+ if (unlikely(__pyx_t_18 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_18);
+ __PYX_ERR(0, 52, __pyx_L1_error)
+ }
+ __pyx_t_20 = (((*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.buf, __pyx_t_19, __pyx_pybuffernd_suppressed.diminfo[0].strides)) == 1) != 0);
+ if (__pyx_t_20) {
+
+ /* "nms.pyx":53
+ * i = order[_i]
+ * if suppressed[i] == 1:
+ * continue # <<<<<<<<<<<<<<
+ * keep.append(i)
+ * ix1 = x1[i]
+ */
+ goto __pyx_L3_continue;
+
+ /* "nms.pyx":52
+ * for _i in range(ndets):
+ * i = order[_i]
+ * if suppressed[i] == 1: # <<<<<<<<<<<<<<
+ * continue
+ * keep.append(i)
+ */
+ }
+
+ /* "nms.pyx":54
+ * if suppressed[i] == 1:
+ * continue
+ * keep.append(i) # <<<<<<<<<<<<<<
+ * ix1 = x1[i]
+ * iy1 = y1[i]
+ */
+ __pyx_t_12 = __Pyx_PyInt_From_int(__pyx_v_i); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 54, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_12);
+ __pyx_t_21 = __Pyx_PyList_Append(__pyx_v_keep, __pyx_t_12); if (unlikely(__pyx_t_21 == ((int)-1))) __PYX_ERR(0, 54, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+
+ /* "nms.pyx":55
+ * continue
+ * keep.append(i)
+ * ix1 = x1[i] # <<<<<<<<<<<<<<
+ * iy1 = y1[i]
+ * ix2 = x2[i]
+ */
+ __pyx_t_22 = __pyx_v_i;
+ __pyx_t_18 = -1;
+ if (__pyx_t_22 < 0) {
+ __pyx_t_22 += __pyx_pybuffernd_x1.diminfo[0].shape;
+ if (unlikely(__pyx_t_22 < 0)) __pyx_t_18 = 0;
+ } else if (unlikely(__pyx_t_22 >= __pyx_pybuffernd_x1.diminfo[0].shape)) __pyx_t_18 = 0;
+ if (unlikely(__pyx_t_18 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_18);
+ __PYX_ERR(0, 55, __pyx_L1_error)
+ }
+ __pyx_v_ix1 = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_x1.rcbuffer->pybuffer.buf, __pyx_t_22, __pyx_pybuffernd_x1.diminfo[0].strides));
+
+ /* "nms.pyx":56
+ * keep.append(i)
+ * ix1 = x1[i]
+ * iy1 = y1[i] # <<<<<<<<<<<<<<
+ * ix2 = x2[i]
+ * iy2 = y2[i]
+ */
+ __pyx_t_23 = __pyx_v_i;
+ __pyx_t_18 = -1;
+ if (__pyx_t_23 < 0) {
+ __pyx_t_23 += __pyx_pybuffernd_y1.diminfo[0].shape;
+ if (unlikely(__pyx_t_23 < 0)) __pyx_t_18 = 0;
+ } else if (unlikely(__pyx_t_23 >= __pyx_pybuffernd_y1.diminfo[0].shape)) __pyx_t_18 = 0;
+ if (unlikely(__pyx_t_18 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_18);
+ __PYX_ERR(0, 56, __pyx_L1_error)
+ }
+ __pyx_v_iy1 = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_y1.rcbuffer->pybuffer.buf, __pyx_t_23, __pyx_pybuffernd_y1.diminfo[0].strides));
+
+ /* "nms.pyx":57
+ * ix1 = x1[i]
+ * iy1 = y1[i]
+ * ix2 = x2[i] # <<<<<<<<<<<<<<
+ * iy2 = y2[i]
+ * iarea = areas[i]
+ */
+ __pyx_t_24 = __pyx_v_i;
+ __pyx_t_18 = -1;
+ if (__pyx_t_24 < 0) {
+ __pyx_t_24 += __pyx_pybuffernd_x2.diminfo[0].shape;
+ if (unlikely(__pyx_t_24 < 0)) __pyx_t_18 = 0;
+ } else if (unlikely(__pyx_t_24 >= __pyx_pybuffernd_x2.diminfo[0].shape)) __pyx_t_18 = 0;
+ if (unlikely(__pyx_t_18 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_18);
+ __PYX_ERR(0, 57, __pyx_L1_error)
+ }
+ __pyx_v_ix2 = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_x2.rcbuffer->pybuffer.buf, __pyx_t_24, __pyx_pybuffernd_x2.diminfo[0].strides));
+
+ /* "nms.pyx":58
+ * iy1 = y1[i]
+ * ix2 = x2[i]
+ * iy2 = y2[i] # <<<<<<<<<<<<<<
+ * iarea = areas[i]
+ * for _j in range(_i + 1, ndets):
+ */
+ __pyx_t_25 = __pyx_v_i;
+ __pyx_t_18 = -1;
+ if (__pyx_t_25 < 0) {
+ __pyx_t_25 += __pyx_pybuffernd_y2.diminfo[0].shape;
+ if (unlikely(__pyx_t_25 < 0)) __pyx_t_18 = 0;
+ } else if (unlikely(__pyx_t_25 >= __pyx_pybuffernd_y2.diminfo[0].shape)) __pyx_t_18 = 0;
+ if (unlikely(__pyx_t_18 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_18);
+ __PYX_ERR(0, 58, __pyx_L1_error)
+ }
+ __pyx_v_iy2 = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_y2.rcbuffer->pybuffer.buf, __pyx_t_25, __pyx_pybuffernd_y2.diminfo[0].strides));
+
+ /* "nms.pyx":59
+ * ix2 = x2[i]
+ * iy2 = y2[i]
+ * iarea = areas[i] # <<<<<<<<<<<<<<
+ * for _j in range(_i + 1, ndets):
+ * j = order[_j]
+ */
+ __pyx_t_26 = __pyx_v_i;
+ __pyx_t_18 = -1;
+ if (__pyx_t_26 < 0) {
+ __pyx_t_26 += __pyx_pybuffernd_areas.diminfo[0].shape;
+ if (unlikely(__pyx_t_26 < 0)) __pyx_t_18 = 0;
+ } else if (unlikely(__pyx_t_26 >= __pyx_pybuffernd_areas.diminfo[0].shape)) __pyx_t_18 = 0;
+ if (unlikely(__pyx_t_18 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_18);
+ __PYX_ERR(0, 59, __pyx_L1_error)
+ }
+ __pyx_v_iarea = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_areas.rcbuffer->pybuffer.buf, __pyx_t_26, __pyx_pybuffernd_areas.diminfo[0].strides));
+
+ /* "nms.pyx":60
+ * iy2 = y2[i]
+ * iarea = areas[i]
+ * for _j in range(_i + 1, ndets): # <<<<<<<<<<<<<<
+ * j = order[_j]
+ * if suppressed[j] == 1:
+ */
+ __pyx_t_18 = __pyx_v_ndets;
+ __pyx_t_27 = __pyx_t_18;
+ for (__pyx_t_28 = (__pyx_v__i + 1); __pyx_t_28 < __pyx_t_27; __pyx_t_28+=1) {
+ __pyx_v__j = __pyx_t_28;
+
+ /* "nms.pyx":61
+ * iarea = areas[i]
+ * for _j in range(_i + 1, ndets):
+ * j = order[_j] # <<<<<<<<<<<<<<
+ * if suppressed[j] == 1:
+ * continue
+ */
+ __pyx_t_29 = __pyx_v__j;
+ __pyx_t_30 = -1;
+ if (__pyx_t_29 < 0) {
+ __pyx_t_29 += __pyx_pybuffernd_order.diminfo[0].shape;
+ if (unlikely(__pyx_t_29 < 0)) __pyx_t_30 = 0;
+ } else if (unlikely(__pyx_t_29 >= __pyx_pybuffernd_order.diminfo[0].shape)) __pyx_t_30 = 0;
+ if (unlikely(__pyx_t_30 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_30);
+ __PYX_ERR(0, 61, __pyx_L1_error)
+ }
+ __pyx_v_j = (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_order.rcbuffer->pybuffer.buf, __pyx_t_29, __pyx_pybuffernd_order.diminfo[0].strides));
+
+ /* "nms.pyx":62
+ * for _j in range(_i + 1, ndets):
+ * j = order[_j]
+ * if suppressed[j] == 1: # <<<<<<<<<<<<<<
+ * continue
+ * xx1 = max(ix1, x1[j])
+ */
+ __pyx_t_31 = __pyx_v_j;
+ __pyx_t_30 = -1;
+ if (__pyx_t_31 < 0) {
+ __pyx_t_31 += __pyx_pybuffernd_suppressed.diminfo[0].shape;
+ if (unlikely(__pyx_t_31 < 0)) __pyx_t_30 = 0;
+ } else if (unlikely(__pyx_t_31 >= __pyx_pybuffernd_suppressed.diminfo[0].shape)) __pyx_t_30 = 0;
+ if (unlikely(__pyx_t_30 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_30);
+ __PYX_ERR(0, 62, __pyx_L1_error)
+ }
+ __pyx_t_20 = (((*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.buf, __pyx_t_31, __pyx_pybuffernd_suppressed.diminfo[0].strides)) == 1) != 0);
+ if (__pyx_t_20) {
+
+ /* "nms.pyx":63
+ * j = order[_j]
+ * if suppressed[j] == 1:
+ * continue # <<<<<<<<<<<<<<
+ * xx1 = max(ix1, x1[j])
+ * yy1 = max(iy1, y1[j])
+ */
+ goto __pyx_L6_continue;
+
+ /* "nms.pyx":62
+ * for _j in range(_i + 1, ndets):
+ * j = order[_j]
+ * if suppressed[j] == 1: # <<<<<<<<<<<<<<
+ * continue
+ * xx1 = max(ix1, x1[j])
+ */
+ }
+
+ /* "nms.pyx":64
+ * if suppressed[j] == 1:
+ * continue
+ * xx1 = max(ix1, x1[j]) # <<<<<<<<<<<<<<
+ * yy1 = max(iy1, y1[j])
+ * xx2 = min(ix2, x2[j])
+ */
+ __pyx_t_32 = __pyx_v_j;
+ __pyx_t_30 = -1;
+ if (__pyx_t_32 < 0) {
+ __pyx_t_32 += __pyx_pybuffernd_x1.diminfo[0].shape;
+ if (unlikely(__pyx_t_32 < 0)) __pyx_t_30 = 0;
+ } else if (unlikely(__pyx_t_32 >= __pyx_pybuffernd_x1.diminfo[0].shape)) __pyx_t_30 = 0;
+ if (unlikely(__pyx_t_30 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_30);
+ __PYX_ERR(0, 64, __pyx_L1_error)
+ }
+ __pyx_v_xx1 = __pyx_f_3nms_max(__pyx_v_ix1, (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_x1.rcbuffer->pybuffer.buf, __pyx_t_32, __pyx_pybuffernd_x1.diminfo[0].strides)));
+
+ /* "nms.pyx":65
+ * continue
+ * xx1 = max(ix1, x1[j])
+ * yy1 = max(iy1, y1[j]) # <<<<<<<<<<<<<<
+ * xx2 = min(ix2, x2[j])
+ * yy2 = min(iy2, y2[j])
+ */
+ __pyx_t_33 = __pyx_v_j;
+ __pyx_t_30 = -1;
+ if (__pyx_t_33 < 0) {
+ __pyx_t_33 += __pyx_pybuffernd_y1.diminfo[0].shape;
+ if (unlikely(__pyx_t_33 < 0)) __pyx_t_30 = 0;
+ } else if (unlikely(__pyx_t_33 >= __pyx_pybuffernd_y1.diminfo[0].shape)) __pyx_t_30 = 0;
+ if (unlikely(__pyx_t_30 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_30);
+ __PYX_ERR(0, 65, __pyx_L1_error)
+ }
+ __pyx_v_yy1 = __pyx_f_3nms_max(__pyx_v_iy1, (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_y1.rcbuffer->pybuffer.buf, __pyx_t_33, __pyx_pybuffernd_y1.diminfo[0].strides)));
+
+ /* "nms.pyx":66
+ * xx1 = max(ix1, x1[j])
+ * yy1 = max(iy1, y1[j])
+ * xx2 = min(ix2, x2[j]) # <<<<<<<<<<<<<<
+ * yy2 = min(iy2, y2[j])
+ * w = max(0.0, xx2 - xx1 + 1)
+ */
+ __pyx_t_34 = __pyx_v_j;
+ __pyx_t_30 = -1;
+ if (__pyx_t_34 < 0) {
+ __pyx_t_34 += __pyx_pybuffernd_x2.diminfo[0].shape;
+ if (unlikely(__pyx_t_34 < 0)) __pyx_t_30 = 0;
+ } else if (unlikely(__pyx_t_34 >= __pyx_pybuffernd_x2.diminfo[0].shape)) __pyx_t_30 = 0;
+ if (unlikely(__pyx_t_30 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_30);
+ __PYX_ERR(0, 66, __pyx_L1_error)
+ }
+ __pyx_v_xx2 = __pyx_f_3nms_min(__pyx_v_ix2, (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_x2.rcbuffer->pybuffer.buf, __pyx_t_34, __pyx_pybuffernd_x2.diminfo[0].strides)));
+
+ /* "nms.pyx":67
+ * yy1 = max(iy1, y1[j])
+ * xx2 = min(ix2, x2[j])
+ * yy2 = min(iy2, y2[j]) # <<<<<<<<<<<<<<
+ * w = max(0.0, xx2 - xx1 + 1)
+ * h = max(0.0, yy2 - yy1 + 1)
+ */
+ __pyx_t_35 = __pyx_v_j;
+ __pyx_t_30 = -1;
+ if (__pyx_t_35 < 0) {
+ __pyx_t_35 += __pyx_pybuffernd_y2.diminfo[0].shape;
+ if (unlikely(__pyx_t_35 < 0)) __pyx_t_30 = 0;
+ } else if (unlikely(__pyx_t_35 >= __pyx_pybuffernd_y2.diminfo[0].shape)) __pyx_t_30 = 0;
+ if (unlikely(__pyx_t_30 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_30);
+ __PYX_ERR(0, 67, __pyx_L1_error)
+ }
+ __pyx_v_yy2 = __pyx_f_3nms_min(__pyx_v_iy2, (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_y2.rcbuffer->pybuffer.buf, __pyx_t_35, __pyx_pybuffernd_y2.diminfo[0].strides)));
+
+ /* "nms.pyx":68
+ * xx2 = min(ix2, x2[j])
+ * yy2 = min(iy2, y2[j])
+ * w = max(0.0, xx2 - xx1 + 1) # <<<<<<<<<<<<<<
+ * h = max(0.0, yy2 - yy1 + 1)
+ * inter = w * h
+ */
+ __pyx_v_w = __pyx_f_3nms_max(0.0, ((__pyx_v_xx2 - __pyx_v_xx1) + 1.0));
+
+ /* "nms.pyx":69
+ * yy2 = min(iy2, y2[j])
+ * w = max(0.0, xx2 - xx1 + 1)
+ * h = max(0.0, yy2 - yy1 + 1) # <<<<<<<<<<<<<<
+ * inter = w * h
+ * ovr = inter / (iarea + areas[j] - inter)
+ */
+ __pyx_v_h = __pyx_f_3nms_max(0.0, ((__pyx_v_yy2 - __pyx_v_yy1) + 1.0));
+
+ /* "nms.pyx":70
+ * w = max(0.0, xx2 - xx1 + 1)
+ * h = max(0.0, yy2 - yy1 + 1)
+ * inter = w * h # <<<<<<<<<<<<<<
+ * ovr = inter / (iarea + areas[j] - inter)
+ * if ovr >= thresh:
+ */
+ __pyx_v_inter = (__pyx_v_w * __pyx_v_h);
+
+ /* "nms.pyx":71
+ * h = max(0.0, yy2 - yy1 + 1)
+ * inter = w * h
+ * ovr = inter / (iarea + areas[j] - inter) # <<<<<<<<<<<<<<
+ * if ovr >= thresh:
+ * suppressed[j] = 1
+ */
+ __pyx_t_36 = __pyx_v_j;
+ __pyx_t_30 = -1;
+ if (__pyx_t_36 < 0) {
+ __pyx_t_36 += __pyx_pybuffernd_areas.diminfo[0].shape;
+ if (unlikely(__pyx_t_36 < 0)) __pyx_t_30 = 0;
+ } else if (unlikely(__pyx_t_36 >= __pyx_pybuffernd_areas.diminfo[0].shape)) __pyx_t_30 = 0;
+ if (unlikely(__pyx_t_30 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_30);
+ __PYX_ERR(0, 71, __pyx_L1_error)
+ }
+ __pyx_t_37 = ((__pyx_v_iarea + (*__Pyx_BufPtrStrided1d(__pyx_t_5numpy_float32_t *, __pyx_pybuffernd_areas.rcbuffer->pybuffer.buf, __pyx_t_36, __pyx_pybuffernd_areas.diminfo[0].strides))) - __pyx_v_inter);
+ if (unlikely(__pyx_t_37 == 0)) {
+ PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+ __PYX_ERR(0, 71, __pyx_L1_error)
+ }
+ __pyx_v_ovr = (__pyx_v_inter / __pyx_t_37);
+
+ /* "nms.pyx":72
+ * inter = w * h
+ * ovr = inter / (iarea + areas[j] - inter)
+ * if ovr >= thresh: # <<<<<<<<<<<<<<
+ * suppressed[j] = 1
+ *
+ */
+ __pyx_t_12 = PyFloat_FromDouble(__pyx_v_ovr); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 72, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_12);
+ __pyx_t_8 = PyObject_RichCompare(__pyx_t_12, __pyx_v_thresh, Py_GE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 72, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
+ __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_20 < 0)) __PYX_ERR(0, 72, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ if (__pyx_t_20) {
+
+ /* "nms.pyx":73
+ * ovr = inter / (iarea + areas[j] - inter)
+ * if ovr >= thresh:
+ * suppressed[j] = 1 # <<<<<<<<<<<<<<
+ *
+ * return keep
+ */
+ __pyx_t_38 = __pyx_v_j;
+ __pyx_t_30 = -1;
+ if (__pyx_t_38 < 0) {
+ __pyx_t_38 += __pyx_pybuffernd_suppressed.diminfo[0].shape;
+ if (unlikely(__pyx_t_38 < 0)) __pyx_t_30 = 0;
+ } else if (unlikely(__pyx_t_38 >= __pyx_pybuffernd_suppressed.diminfo[0].shape)) __pyx_t_30 = 0;
+ if (unlikely(__pyx_t_30 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_30);
+ __PYX_ERR(0, 73, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided1d(__pyx_t_5numpy_int_t *, __pyx_pybuffernd_suppressed.rcbuffer->pybuffer.buf, __pyx_t_38, __pyx_pybuffernd_suppressed.diminfo[0].strides) = 1;
+
+ /* "nms.pyx":72
+ * inter = w * h
+ * ovr = inter / (iarea + areas[j] - inter)
+ * if ovr >= thresh: # <<<<<<<<<<<<<<
+ * suppressed[j] = 1
+ *
+ */
+ }
+ __pyx_L6_continue:;
+ }
+ __pyx_L3_continue:;
+ }
+
+ /* "nms.pyx":75
+ * suppressed[j] = 1
+ *
+ * return keep # <<<<<<<<<<<<<<
+ *
+ * def soft_nms(np.ndarray[float, ndim=2] boxes, float sigma=0.5, float Nt=0.3, float threshold=0.001, unsigned int method=0):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(__pyx_v_keep);
+ __pyx_r = __pyx_v_keep;
+ goto __pyx_L0;
+
+ /* "nms.pyx":24
+ * return a if a <= b else b
+ *
+ * def nms(np.ndarray[np.float32_t, ndim=2] dets, np.float thresh): # <<<<<<<<<<<<<<
+ * cdef np.ndarray[np.float32_t, ndim=1] x1 = dets[:, 0]
+ * cdef np.ndarray[np.float32_t, ndim=1] y1 = dets[:, 1]
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_7);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_XDECREF(__pyx_t_11);
+ __Pyx_XDECREF(__pyx_t_12);
+ { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
+ __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_areas.rcbuffer->pybuffer);
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_dets.rcbuffer->pybuffer);
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_order.rcbuffer->pybuffer);
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_scores.rcbuffer->pybuffer);
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_suppressed.rcbuffer->pybuffer);
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x1.rcbuffer->pybuffer);
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x2.rcbuffer->pybuffer);
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_y1.rcbuffer->pybuffer);
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_y2.rcbuffer->pybuffer);
+ __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+ __Pyx_AddTraceback("nms.nms", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ goto __pyx_L2;
+ __pyx_L0:;
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_areas.rcbuffer->pybuffer);
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_dets.rcbuffer->pybuffer);
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_order.rcbuffer->pybuffer);
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_scores.rcbuffer->pybuffer);
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_suppressed.rcbuffer->pybuffer);
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x1.rcbuffer->pybuffer);
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x2.rcbuffer->pybuffer);
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_y1.rcbuffer->pybuffer);
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_y2.rcbuffer->pybuffer);
+ __pyx_L2:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_x1);
+ __Pyx_XDECREF((PyObject *)__pyx_v_y1);
+ __Pyx_XDECREF((PyObject *)__pyx_v_x2);
+ __Pyx_XDECREF((PyObject *)__pyx_v_y2);
+ __Pyx_XDECREF((PyObject *)__pyx_v_scores);
+ __Pyx_XDECREF((PyObject *)__pyx_v_areas);
+ __Pyx_XDECREF((PyObject *)__pyx_v_order);
+ __Pyx_XDECREF((PyObject *)__pyx_v_suppressed);
+ __Pyx_XDECREF(__pyx_v_keep);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "nms.pyx":77
+ * return keep
+ *
+ * def soft_nms(np.ndarray[float, ndim=2] boxes, float sigma=0.5, float Nt=0.3, float threshold=0.001, unsigned int method=0): # <<<<<<<<<<<<<<
+ * cdef unsigned int N = boxes.shape[0]
+ * cdef float iw, ih, box_area
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3nms_3soft_nms(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_3nms_3soft_nms = {"soft_nms", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3nms_3soft_nms, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_3nms_3soft_nms(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyArrayObject *__pyx_v_boxes = 0;
+ float __pyx_v_sigma;
+ float __pyx_v_Nt;
+ float __pyx_v_threshold;
+ unsigned int __pyx_v_method;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("soft_nms (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_boxes,&__pyx_n_s_sigma,&__pyx_n_s_Nt,&__pyx_n_s_threshold,&__pyx_n_s_method,0};
+ PyObject* values[5] = {0,0,0,0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ CYTHON_FALLTHROUGH;
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ CYTHON_FALLTHROUGH;
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ CYTHON_FALLTHROUGH;
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ CYTHON_FALLTHROUGH;
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ CYTHON_FALLTHROUGH;
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_boxes)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ CYTHON_FALLTHROUGH;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sigma);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ CYTHON_FALLTHROUGH;
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Nt);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ CYTHON_FALLTHROUGH;
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_threshold);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ CYTHON_FALLTHROUGH;
+ case 4:
+ if (kw_args > 0) {
+ PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_method);
+ if (value) { values[4] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "soft_nms") < 0)) __PYX_ERR(0, 77, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ CYTHON_FALLTHROUGH;
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ CYTHON_FALLTHROUGH;
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ CYTHON_FALLTHROUGH;
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ CYTHON_FALLTHROUGH;
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ __pyx_v_boxes = ((PyArrayObject *)values[0]);
+ if (values[1]) {
+ __pyx_v_sigma = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_sigma == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 77, __pyx_L3_error)
+ } else {
+ __pyx_v_sigma = ((float)0.5);
+ }
+ if (values[2]) {
+ __pyx_v_Nt = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_Nt == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 77, __pyx_L3_error)
+ } else {
+ __pyx_v_Nt = ((float)0.3);
+ }
+ if (values[3]) {
+ __pyx_v_threshold = __pyx_PyFloat_AsFloat(values[3]); if (unlikely((__pyx_v_threshold == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 77, __pyx_L3_error)
+ } else {
+ __pyx_v_threshold = ((float)0.001);
+ }
+ if (values[4]) {
+ __pyx_v_method = __Pyx_PyInt_As_unsigned_int(values[4]); if (unlikely((__pyx_v_method == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 77, __pyx_L3_error)
+ } else {
+ __pyx_v_method = ((unsigned int)0);
+ }
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("soft_nms", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 77, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("nms.soft_nms", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_boxes), __pyx_ptype_5numpy_ndarray, 1, "boxes", 0))) __PYX_ERR(0, 77, __pyx_L1_error)
+ __pyx_r = __pyx_pf_3nms_2soft_nms(__pyx_self, __pyx_v_boxes, __pyx_v_sigma, __pyx_v_Nt, __pyx_v_threshold, __pyx_v_method);
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3nms_2soft_nms(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, float __pyx_v_sigma, float __pyx_v_Nt, float __pyx_v_threshold, unsigned int __pyx_v_method) {
+ unsigned int __pyx_v_N;
+ float __pyx_v_iw;
+ float __pyx_v_ih;
+ float __pyx_v_ua;
+ int __pyx_v_pos;
+ float __pyx_v_maxscore;
+ int __pyx_v_maxpos;
+ float __pyx_v_x1;
+ float __pyx_v_x2;
+ float __pyx_v_y1;
+ float __pyx_v_y2;
+ float __pyx_v_tx1;
+ float __pyx_v_tx2;
+ float __pyx_v_ty1;
+ float __pyx_v_ty2;
+ float __pyx_v_ts;
+ float __pyx_v_area;
+ float __pyx_v_weight;
+ float __pyx_v_ov;
+ PyObject *__pyx_v_i = NULL;
+ CYTHON_UNUSED PyObject *__pyx_v_s = NULL;
+ PyObject *__pyx_v_keep = NULL;
+ __Pyx_LocalBuf_ND __pyx_pybuffernd_boxes;
+ __Pyx_Buffer __pyx_pybuffer_boxes;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ Py_ssize_t __pyx_t_3;
+ PyObject *(*__pyx_t_4)(PyObject *);
+ PyObject *__pyx_t_5 = NULL;
+ float __pyx_t_6;
+ int __pyx_t_7;
+ int __pyx_t_8;
+ Py_ssize_t __pyx_t_9;
+ Py_ssize_t __pyx_t_10;
+ Py_ssize_t __pyx_t_11;
+ Py_ssize_t __pyx_t_12;
+ Py_ssize_t __pyx_t_13;
+ Py_ssize_t __pyx_t_14;
+ Py_ssize_t __pyx_t_15;
+ Py_ssize_t __pyx_t_16;
+ Py_ssize_t __pyx_t_17;
+ Py_ssize_t __pyx_t_18;
+ Py_ssize_t __pyx_t_19;
+ Py_ssize_t __pyx_t_20;
+ Py_ssize_t __pyx_t_21;
+ Py_ssize_t __pyx_t_22;
+ Py_ssize_t __pyx_t_23;
+ Py_ssize_t __pyx_t_24;
+ Py_ssize_t __pyx_t_25;
+ Py_ssize_t __pyx_t_26;
+ Py_ssize_t __pyx_t_27;
+ Py_ssize_t __pyx_t_28;
+ Py_ssize_t __pyx_t_29;
+ Py_ssize_t __pyx_t_30;
+ Py_ssize_t __pyx_t_31;
+ Py_ssize_t __pyx_t_32;
+ Py_ssize_t __pyx_t_33;
+ Py_ssize_t __pyx_t_34;
+ Py_ssize_t __pyx_t_35;
+ Py_ssize_t __pyx_t_36;
+ Py_ssize_t __pyx_t_37;
+ Py_ssize_t __pyx_t_38;
+ Py_ssize_t __pyx_t_39;
+ Py_ssize_t __pyx_t_40;
+ Py_ssize_t __pyx_t_41;
+ Py_ssize_t __pyx_t_42;
+ PyObject *__pyx_t_43 = NULL;
+ PyObject *__pyx_t_44 = NULL;
+ Py_ssize_t __pyx_t_45;
+ Py_ssize_t __pyx_t_46;
+ Py_ssize_t __pyx_t_47;
+ Py_ssize_t __pyx_t_48;
+ Py_ssize_t __pyx_t_49;
+ Py_ssize_t __pyx_t_50;
+ Py_ssize_t __pyx_t_51;
+ Py_ssize_t __pyx_t_52;
+ Py_ssize_t __pyx_t_53;
+ Py_ssize_t __pyx_t_54;
+ Py_ssize_t __pyx_t_55;
+ Py_ssize_t __pyx_t_56;
+ Py_ssize_t __pyx_t_57;
+ Py_ssize_t __pyx_t_58;
+ Py_ssize_t __pyx_t_59;
+ Py_ssize_t __pyx_t_60;
+ Py_ssize_t __pyx_t_61;
+ Py_ssize_t __pyx_t_62;
+ Py_ssize_t __pyx_t_63;
+ Py_ssize_t __pyx_t_64;
+ Py_ssize_t __pyx_t_65;
+ Py_ssize_t __pyx_t_66;
+ Py_ssize_t __pyx_t_67;
+ Py_ssize_t __pyx_t_68;
+ Py_ssize_t __pyx_t_69;
+ Py_ssize_t __pyx_t_70;
+ __Pyx_RefNannySetupContext("soft_nms", 0);
+ __pyx_pybuffer_boxes.pybuffer.buf = NULL;
+ __pyx_pybuffer_boxes.refcount = 0;
+ __pyx_pybuffernd_boxes.data = NULL;
+ __pyx_pybuffernd_boxes.rcbuffer = &__pyx_pybuffer_boxes;
+ {
+ __Pyx_BufFmt_StackElem __pyx_stack[1];
+ if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_boxes, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 77, __pyx_L1_error)
+ }
+ __pyx_pybuffernd_boxes.diminfo[0].strides = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_boxes.diminfo[0].shape = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_boxes.diminfo[1].strides = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_boxes.diminfo[1].shape = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.shape[1];
+
+ /* "nms.pyx":78
+ *
+ * def soft_nms(np.ndarray[float, ndim=2] boxes, float sigma=0.5, float Nt=0.3, float threshold=0.001, unsigned int method=0):
+ * cdef unsigned int N = boxes.shape[0] # <<<<<<<<<<<<<<
+ * cdef float iw, ih, box_area
+ * cdef float ua
+ */
+ __pyx_v_N = (__pyx_v_boxes->dimensions[0]);
+
+ /* "nms.pyx":81
+ * cdef float iw, ih, box_area
+ * cdef float ua
+ * cdef int pos = 0 # <<<<<<<<<<<<<<
+ * cdef float maxscore = 0
+ * cdef int maxpos = 0
+ */
+ __pyx_v_pos = 0;
+
+ /* "nms.pyx":82
+ * cdef float ua
+ * cdef int pos = 0
+ * cdef float maxscore = 0 # <<<<<<<<<<<<<<
+ * cdef int maxpos = 0
+ * cdef float x1,x2,y1,y2,tx1,tx2,ty1,ty2,ts,area,weight,ov
+ */
+ __pyx_v_maxscore = 0.0;
+
+ /* "nms.pyx":83
+ * cdef int pos = 0
+ * cdef float maxscore = 0
+ * cdef int maxpos = 0 # <<<<<<<<<<<<<<
+ * cdef float x1,x2,y1,y2,tx1,tx2,ty1,ty2,ts,area,weight,ov
+ *
+ */
+ __pyx_v_maxpos = 0;
+
+ /* "nms.pyx":86
+ * cdef float x1,x2,y1,y2,tx1,tx2,ty1,ty2,ts,area,weight,ov
+ *
+ * for i in range(N): # <<<<<<<<<<<<<<
+ * maxscore = boxes[i, 4]
+ * maxpos = i
+ */
+ __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_N); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 86, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
+ __pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); __pyx_t_3 = 0;
+ __pyx_t_4 = NULL;
+ } else {
+ __pyx_t_3 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 86, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_4 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 86, __pyx_L1_error)
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ for (;;) {
+ if (likely(!__pyx_t_4)) {
+ if (likely(PyList_CheckExact(__pyx_t_1))) {
+ if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_1)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_3); __Pyx_INCREF(__pyx_t_2); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 86, __pyx_L1_error)
+ #else
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ #endif
+ } else {
+ if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_3); __Pyx_INCREF(__pyx_t_2); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 86, __pyx_L1_error)
+ #else
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ #endif
+ }
+ } else {
+ __pyx_t_2 = __pyx_t_4(__pyx_t_1);
+ if (unlikely(!__pyx_t_2)) {
+ PyObject* exc_type = PyErr_Occurred();
+ if (exc_type) {
+ if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+ else __PYX_ERR(0, 86, __pyx_L1_error)
+ }
+ break;
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ }
+ __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2);
+ __pyx_t_2 = 0;
+
+ /* "nms.pyx":87
+ *
+ * for i in range(N):
+ * maxscore = boxes[i, 4] # <<<<<<<<<<<<<<
+ * maxpos = i
+ *
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_4);
+ __Pyx_GIVEREF(__pyx_int_4);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_4);
+ __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 87, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 87, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_maxscore = __pyx_t_6;
+
+ /* "nms.pyx":88
+ * for i in range(N):
+ * maxscore = boxes[i, 4]
+ * maxpos = i # <<<<<<<<<<<<<<
+ *
+ * tx1 = boxes[i,0]
+ */
+ __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_i); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 88, __pyx_L1_error)
+ __pyx_v_maxpos = __pyx_t_7;
+
+ /* "nms.pyx":90
+ * maxpos = i
+ *
+ * tx1 = boxes[i,0] # <<<<<<<<<<<<<<
+ * ty1 = boxes[i,1]
+ * tx2 = boxes[i,2]
+ */
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 90, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_0);
+ __Pyx_GIVEREF(__pyx_int_0);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_0);
+ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 90, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 90, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_tx1 = __pyx_t_6;
+
+ /* "nms.pyx":91
+ *
+ * tx1 = boxes[i,0]
+ * ty1 = boxes[i,1] # <<<<<<<<<<<<<<
+ * tx2 = boxes[i,2]
+ * ty2 = boxes[i,3]
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 91, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_1);
+ __Pyx_GIVEREF(__pyx_int_1);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_1);
+ __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 91, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 91, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_ty1 = __pyx_t_6;
+
+ /* "nms.pyx":92
+ * tx1 = boxes[i,0]
+ * ty1 = boxes[i,1]
+ * tx2 = boxes[i,2] # <<<<<<<<<<<<<<
+ * ty2 = boxes[i,3]
+ * ts = boxes[i,4]
+ */
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 92, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_2);
+ __Pyx_GIVEREF(__pyx_int_2);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_2);
+ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 92, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 92, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_tx2 = __pyx_t_6;
+
+ /* "nms.pyx":93
+ * ty1 = boxes[i,1]
+ * tx2 = boxes[i,2]
+ * ty2 = boxes[i,3] # <<<<<<<<<<<<<<
+ * ts = boxes[i,4]
+ *
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 93, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_3);
+ __Pyx_GIVEREF(__pyx_int_3);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_3);
+ __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 93, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 93, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_ty2 = __pyx_t_6;
+
+ /* "nms.pyx":94
+ * tx2 = boxes[i,2]
+ * ty2 = boxes[i,3]
+ * ts = boxes[i,4] # <<<<<<<<<<<<<<
+ *
+ * pos = i + 1
+ */
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 94, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_4);
+ __Pyx_GIVEREF(__pyx_int_4);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_4);
+ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 94, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 94, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_ts = __pyx_t_6;
+
+ /* "nms.pyx":96
+ * ts = boxes[i,4]
+ *
+ * pos = i + 1 # <<<<<<<<<<<<<<
+ * # get max box
+ * while pos < N:
+ */
+ __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_v_i, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 96, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 96, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_pos = __pyx_t_7;
+
+ /* "nms.pyx":98
+ * pos = i + 1
+ * # get max box
+ * while pos < N: # <<<<<<<<<<<<<<
+ * if maxscore < boxes[pos, 4]:
+ * maxscore = boxes[pos, 4]
+ */
+ while (1) {
+ __pyx_t_8 = ((__pyx_v_pos < __pyx_v_N) != 0);
+ if (!__pyx_t_8) break;
+
+ /* "nms.pyx":99
+ * # get max box
+ * while pos < N:
+ * if maxscore < boxes[pos, 4]: # <<<<<<<<<<<<<<
+ * maxscore = boxes[pos, 4]
+ * maxpos = pos
+ */
+ __pyx_t_9 = __pyx_v_pos;
+ __pyx_t_10 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_9 < 0) {
+ __pyx_t_9 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_9 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_9 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_10 < 0) {
+ __pyx_t_10 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_10 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_10 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 99, __pyx_L1_error)
+ }
+ __pyx_t_8 = ((__pyx_v_maxscore < (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_9, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_10, __pyx_pybuffernd_boxes.diminfo[1].strides))) != 0);
+ if (__pyx_t_8) {
+
+ /* "nms.pyx":100
+ * while pos < N:
+ * if maxscore < boxes[pos, 4]:
+ * maxscore = boxes[pos, 4] # <<<<<<<<<<<<<<
+ * maxpos = pos
+ * pos = pos + 1
+ */
+ __pyx_t_11 = __pyx_v_pos;
+ __pyx_t_12 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_11 < 0) {
+ __pyx_t_11 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_11 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_11 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_12 < 0) {
+ __pyx_t_12 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_12 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_12 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 100, __pyx_L1_error)
+ }
+ __pyx_v_maxscore = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_12, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":101
+ * if maxscore < boxes[pos, 4]:
+ * maxscore = boxes[pos, 4]
+ * maxpos = pos # <<<<<<<<<<<<<<
+ * pos = pos + 1
+ *
+ */
+ __pyx_v_maxpos = __pyx_v_pos;
+
+ /* "nms.pyx":99
+ * # get max box
+ * while pos < N:
+ * if maxscore < boxes[pos, 4]: # <<<<<<<<<<<<<<
+ * maxscore = boxes[pos, 4]
+ * maxpos = pos
+ */
+ }
+
+ /* "nms.pyx":102
+ * maxscore = boxes[pos, 4]
+ * maxpos = pos
+ * pos = pos + 1 # <<<<<<<<<<<<<<
+ *
+ * # add max box as a detection
+ */
+ __pyx_v_pos = (__pyx_v_pos + 1);
+ }
+
+ /* "nms.pyx":105
+ *
+ * # add max box as a detection
+ * boxes[i,0] = boxes[maxpos,0] # <<<<<<<<<<<<<<
+ * boxes[i,1] = boxes[maxpos,1]
+ * boxes[i,2] = boxes[maxpos,2]
+ */
+ __pyx_t_13 = __pyx_v_maxpos;
+ __pyx_t_14 = 0;
+ __pyx_t_7 = -1;
+ if (__pyx_t_13 < 0) {
+ __pyx_t_13 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_13 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_13 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_14 < 0) {
+ __pyx_t_14 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_14 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_14 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 105, __pyx_L1_error)
+ }
+ __pyx_t_2 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_14, __pyx_pybuffernd_boxes.diminfo[1].strides))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 105, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 105, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_0);
+ __Pyx_GIVEREF(__pyx_int_0);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_0);
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5, __pyx_t_2) < 0)) __PYX_ERR(0, 105, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "nms.pyx":106
+ * # add max box as a detection
+ * boxes[i,0] = boxes[maxpos,0]
+ * boxes[i,1] = boxes[maxpos,1] # <<<<<<<<<<<<<<
+ * boxes[i,2] = boxes[maxpos,2]
+ * boxes[i,3] = boxes[maxpos,3]
+ */
+ __pyx_t_15 = __pyx_v_maxpos;
+ __pyx_t_16 = 1;
+ __pyx_t_7 = -1;
+ if (__pyx_t_15 < 0) {
+ __pyx_t_15 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_15 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_15 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_16 < 0) {
+ __pyx_t_16 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_16 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_16 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 106, __pyx_L1_error)
+ }
+ __pyx_t_2 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_16, __pyx_pybuffernd_boxes.diminfo[1].strides))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 106, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_1);
+ __Pyx_GIVEREF(__pyx_int_1);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_1);
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5, __pyx_t_2) < 0)) __PYX_ERR(0, 106, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "nms.pyx":107
+ * boxes[i,0] = boxes[maxpos,0]
+ * boxes[i,1] = boxes[maxpos,1]
+ * boxes[i,2] = boxes[maxpos,2] # <<<<<<<<<<<<<<
+ * boxes[i,3] = boxes[maxpos,3]
+ * boxes[i,4] = boxes[maxpos,4]
+ */
+ __pyx_t_17 = __pyx_v_maxpos;
+ __pyx_t_18 = 2;
+ __pyx_t_7 = -1;
+ if (__pyx_t_17 < 0) {
+ __pyx_t_17 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_17 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_18 < 0) {
+ __pyx_t_18 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_18 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_18 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 107, __pyx_L1_error)
+ }
+ __pyx_t_2 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_18, __pyx_pybuffernd_boxes.diminfo[1].strides))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 107, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 107, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_2);
+ __Pyx_GIVEREF(__pyx_int_2);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_2);
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5, __pyx_t_2) < 0)) __PYX_ERR(0, 107, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "nms.pyx":108
+ * boxes[i,1] = boxes[maxpos,1]
+ * boxes[i,2] = boxes[maxpos,2]
+ * boxes[i,3] = boxes[maxpos,3] # <<<<<<<<<<<<<<
+ * boxes[i,4] = boxes[maxpos,4]
+ *
+ */
+ __pyx_t_19 = __pyx_v_maxpos;
+ __pyx_t_20 = 3;
+ __pyx_t_7 = -1;
+ if (__pyx_t_19 < 0) {
+ __pyx_t_19 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_19 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_19 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_20 < 0) {
+ __pyx_t_20 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_20 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 108, __pyx_L1_error)
+ }
+ __pyx_t_2 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_19, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_20, __pyx_pybuffernd_boxes.diminfo[1].strides))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 108, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 108, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_3);
+ __Pyx_GIVEREF(__pyx_int_3);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_3);
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5, __pyx_t_2) < 0)) __PYX_ERR(0, 108, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "nms.pyx":109
+ * boxes[i,2] = boxes[maxpos,2]
+ * boxes[i,3] = boxes[maxpos,3]
+ * boxes[i,4] = boxes[maxpos,4] # <<<<<<<<<<<<<<
+ *
+ * # swap ith box with position of max box
+ */
+ __pyx_t_21 = __pyx_v_maxpos;
+ __pyx_t_22 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_21 < 0) {
+ __pyx_t_21 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_21 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_21 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_22 < 0) {
+ __pyx_t_22 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_22 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_22 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 109, __pyx_L1_error)
+ }
+ __pyx_t_2 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_21, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_22, __pyx_pybuffernd_boxes.diminfo[1].strides))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 109, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 109, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_4);
+ __Pyx_GIVEREF(__pyx_int_4);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_4);
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5, __pyx_t_2) < 0)) __PYX_ERR(0, 109, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "nms.pyx":112
+ *
+ * # swap ith box with position of max box
+ * boxes[maxpos,0] = tx1 # <<<<<<<<<<<<<<
+ * boxes[maxpos,1] = ty1
+ * boxes[maxpos,2] = tx2
+ */
+ __pyx_t_23 = __pyx_v_maxpos;
+ __pyx_t_24 = 0;
+ __pyx_t_7 = -1;
+ if (__pyx_t_23 < 0) {
+ __pyx_t_23 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_23 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_23 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_24 < 0) {
+ __pyx_t_24 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_24 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_24 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 112, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_23, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_24, __pyx_pybuffernd_boxes.diminfo[1].strides) = __pyx_v_tx1;
+
+ /* "nms.pyx":113
+ * # swap ith box with position of max box
+ * boxes[maxpos,0] = tx1
+ * boxes[maxpos,1] = ty1 # <<<<<<<<<<<<<<
+ * boxes[maxpos,2] = tx2
+ * boxes[maxpos,3] = ty2
+ */
+ __pyx_t_25 = __pyx_v_maxpos;
+ __pyx_t_26 = 1;
+ __pyx_t_7 = -1;
+ if (__pyx_t_25 < 0) {
+ __pyx_t_25 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_25 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_25 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_26 < 0) {
+ __pyx_t_26 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_26 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_26 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 113, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_25, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_26, __pyx_pybuffernd_boxes.diminfo[1].strides) = __pyx_v_ty1;
+
+ /* "nms.pyx":114
+ * boxes[maxpos,0] = tx1
+ * boxes[maxpos,1] = ty1
+ * boxes[maxpos,2] = tx2 # <<<<<<<<<<<<<<
+ * boxes[maxpos,3] = ty2
+ * boxes[maxpos,4] = ts
+ */
+ __pyx_t_27 = __pyx_v_maxpos;
+ __pyx_t_28 = 2;
+ __pyx_t_7 = -1;
+ if (__pyx_t_27 < 0) {
+ __pyx_t_27 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_27 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_27 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_28 < 0) {
+ __pyx_t_28 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_28 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_28 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 114, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_27, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_28, __pyx_pybuffernd_boxes.diminfo[1].strides) = __pyx_v_tx2;
+
+ /* "nms.pyx":115
+ * boxes[maxpos,1] = ty1
+ * boxes[maxpos,2] = tx2
+ * boxes[maxpos,3] = ty2 # <<<<<<<<<<<<<<
+ * boxes[maxpos,4] = ts
+ *
+ */
+ __pyx_t_29 = __pyx_v_maxpos;
+ __pyx_t_30 = 3;
+ __pyx_t_7 = -1;
+ if (__pyx_t_29 < 0) {
+ __pyx_t_29 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_29 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_29 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_30 < 0) {
+ __pyx_t_30 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_30 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_30 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 115, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_29, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_30, __pyx_pybuffernd_boxes.diminfo[1].strides) = __pyx_v_ty2;
+
+ /* "nms.pyx":116
+ * boxes[maxpos,2] = tx2
+ * boxes[maxpos,3] = ty2
+ * boxes[maxpos,4] = ts # <<<<<<<<<<<<<<
+ *
+ * tx1 = boxes[i,0]
+ */
+ __pyx_t_31 = __pyx_v_maxpos;
+ __pyx_t_32 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_31 < 0) {
+ __pyx_t_31 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_31 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_31 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_32 < 0) {
+ __pyx_t_32 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_32 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_32 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 116, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_31, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_32, __pyx_pybuffernd_boxes.diminfo[1].strides) = __pyx_v_ts;
+
+ /* "nms.pyx":118
+ * boxes[maxpos,4] = ts
+ *
+ * tx1 = boxes[i,0] # <<<<<<<<<<<<<<
+ * ty1 = boxes[i,1]
+ * tx2 = boxes[i,2]
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 118, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_0);
+ __Pyx_GIVEREF(__pyx_int_0);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_0);
+ __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 118, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 118, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_tx1 = __pyx_t_6;
+
+ /* "nms.pyx":119
+ *
+ * tx1 = boxes[i,0]
+ * ty1 = boxes[i,1] # <<<<<<<<<<<<<<
+ * tx2 = boxes[i,2]
+ * ty2 = boxes[i,3]
+ */
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 119, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_1);
+ __Pyx_GIVEREF(__pyx_int_1);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_1);
+ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 119, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 119, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_ty1 = __pyx_t_6;
+
+ /* "nms.pyx":120
+ * tx1 = boxes[i,0]
+ * ty1 = boxes[i,1]
+ * tx2 = boxes[i,2] # <<<<<<<<<<<<<<
+ * ty2 = boxes[i,3]
+ * ts = boxes[i,4]
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 120, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_2);
+ __Pyx_GIVEREF(__pyx_int_2);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_2);
+ __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 120, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 120, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_tx2 = __pyx_t_6;
+
+ /* "nms.pyx":121
+ * ty1 = boxes[i,1]
+ * tx2 = boxes[i,2]
+ * ty2 = boxes[i,3] # <<<<<<<<<<<<<<
+ * ts = boxes[i,4]
+ *
+ */
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 121, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_3);
+ __Pyx_GIVEREF(__pyx_int_3);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_3);
+ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 121, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 121, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_ty2 = __pyx_t_6;
+
+ /* "nms.pyx":122
+ * tx2 = boxes[i,2]
+ * ty2 = boxes[i,3]
+ * ts = boxes[i,4] # <<<<<<<<<<<<<<
+ *
+ * pos = i + 1
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 122, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_4);
+ __Pyx_GIVEREF(__pyx_int_4);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_4);
+ __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 122, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 122, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_ts = __pyx_t_6;
+
+ /* "nms.pyx":124
+ * ts = boxes[i,4]
+ *
+ * pos = i + 1 # <<<<<<<<<<<<<<
+ * # NMS iterations, note that N changes if detection boxes fall below threshold
+ * while pos < N:
+ */
+ __pyx_t_5 = __Pyx_PyInt_AddObjC(__pyx_v_i, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 124, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_pos = __pyx_t_7;
+
+ /* "nms.pyx":126
+ * pos = i + 1
+ * # NMS iterations, note that N changes if detection boxes fall below threshold
+ * while pos < N: # <<<<<<<<<<<<<<
+ * x1 = boxes[pos, 0]
+ * y1 = boxes[pos, 1]
+ */
+ while (1) {
+ __pyx_t_8 = ((__pyx_v_pos < __pyx_v_N) != 0);
+ if (!__pyx_t_8) break;
+
+ /* "nms.pyx":127
+ * # NMS iterations, note that N changes if detection boxes fall below threshold
+ * while pos < N:
+ * x1 = boxes[pos, 0] # <<<<<<<<<<<<<<
+ * y1 = boxes[pos, 1]
+ * x2 = boxes[pos, 2]
+ */
+ __pyx_t_33 = __pyx_v_pos;
+ __pyx_t_34 = 0;
+ __pyx_t_7 = -1;
+ if (__pyx_t_33 < 0) {
+ __pyx_t_33 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_33 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_33 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_34 < 0) {
+ __pyx_t_34 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_34 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_34 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 127, __pyx_L1_error)
+ }
+ __pyx_v_x1 = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_33, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_34, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":128
+ * while pos < N:
+ * x1 = boxes[pos, 0]
+ * y1 = boxes[pos, 1] # <<<<<<<<<<<<<<
+ * x2 = boxes[pos, 2]
+ * y2 = boxes[pos, 3]
+ */
+ __pyx_t_35 = __pyx_v_pos;
+ __pyx_t_36 = 1;
+ __pyx_t_7 = -1;
+ if (__pyx_t_35 < 0) {
+ __pyx_t_35 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_35 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_35 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_36 < 0) {
+ __pyx_t_36 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_36 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_36 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 128, __pyx_L1_error)
+ }
+ __pyx_v_y1 = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_35, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_36, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":129
+ * x1 = boxes[pos, 0]
+ * y1 = boxes[pos, 1]
+ * x2 = boxes[pos, 2] # <<<<<<<<<<<<<<
+ * y2 = boxes[pos, 3]
+ * s = boxes[pos, 4]
+ */
+ __pyx_t_37 = __pyx_v_pos;
+ __pyx_t_38 = 2;
+ __pyx_t_7 = -1;
+ if (__pyx_t_37 < 0) {
+ __pyx_t_37 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_37 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_37 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_38 < 0) {
+ __pyx_t_38 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_38 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_38 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 129, __pyx_L1_error)
+ }
+ __pyx_v_x2 = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_37, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_38, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":130
+ * y1 = boxes[pos, 1]
+ * x2 = boxes[pos, 2]
+ * y2 = boxes[pos, 3] # <<<<<<<<<<<<<<
+ * s = boxes[pos, 4]
+ *
+ */
+ __pyx_t_39 = __pyx_v_pos;
+ __pyx_t_40 = 3;
+ __pyx_t_7 = -1;
+ if (__pyx_t_39 < 0) {
+ __pyx_t_39 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_39 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_39 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_40 < 0) {
+ __pyx_t_40 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_40 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_40 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 130, __pyx_L1_error)
+ }
+ __pyx_v_y2 = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_39, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_40, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":131
+ * x2 = boxes[pos, 2]
+ * y2 = boxes[pos, 3]
+ * s = boxes[pos, 4] # <<<<<<<<<<<<<<
+ *
+ * area = (x2 - x1 + 1) * (y2 - y1 + 1)
+ */
+ __pyx_t_41 = __pyx_v_pos;
+ __pyx_t_42 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_41 < 0) {
+ __pyx_t_41 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_41 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_41 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_42 < 0) {
+ __pyx_t_42 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_42 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_42 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 131, __pyx_L1_error)
+ }
+ __pyx_t_5 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_41, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_42, __pyx_pybuffernd_boxes.diminfo[1].strides))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 131, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_XDECREF_SET(__pyx_v_s, __pyx_t_5);
+ __pyx_t_5 = 0;
+
+ /* "nms.pyx":133
+ * s = boxes[pos, 4]
+ *
+ * area = (x2 - x1 + 1) * (y2 - y1 + 1) # <<<<<<<<<<<<<<
+ * iw = (min(tx2, x2) - max(tx1, x1) + 1)
+ * if iw > 0:
+ */
+ __pyx_v_area = (((__pyx_v_x2 - __pyx_v_x1) + 1.0) * ((__pyx_v_y2 - __pyx_v_y1) + 1.0));
+
+ /* "nms.pyx":134
+ *
+ * area = (x2 - x1 + 1) * (y2 - y1 + 1)
+ * iw = (min(tx2, x2) - max(tx1, x1) + 1) # <<<<<<<<<<<<<<
+ * if iw > 0:
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1)
+ */
+ __pyx_v_iw = ((__pyx_f_3nms_min(__pyx_v_tx2, __pyx_v_x2) - __pyx_f_3nms_max(__pyx_v_tx1, __pyx_v_x1)) + 1.0);
+
+ /* "nms.pyx":135
+ * area = (x2 - x1 + 1) * (y2 - y1 + 1)
+ * iw = (min(tx2, x2) - max(tx1, x1) + 1)
+ * if iw > 0: # <<<<<<<<<<<<<<
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1)
+ * if ih > 0:
+ */
+ __pyx_t_8 = ((__pyx_v_iw > 0.0) != 0);
+ if (__pyx_t_8) {
+
+ /* "nms.pyx":136
+ * iw = (min(tx2, x2) - max(tx1, x1) + 1)
+ * if iw > 0:
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1) # <<<<<<<<<<<<<<
+ * if ih > 0:
+ * ua = float((tx2 - tx1 + 1) * (ty2 - ty1 + 1) + area - iw * ih)
+ */
+ __pyx_v_ih = ((__pyx_f_3nms_min(__pyx_v_ty2, __pyx_v_y2) - __pyx_f_3nms_max(__pyx_v_ty1, __pyx_v_y1)) + 1.0);
+
+ /* "nms.pyx":137
+ * if iw > 0:
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1)
+ * if ih > 0: # <<<<<<<<<<<<<<
+ * ua = float((tx2 - tx1 + 1) * (ty2 - ty1 + 1) + area - iw * ih)
+ * ov = iw * ih / ua #iou between max box and detection box
+ */
+ __pyx_t_8 = ((__pyx_v_ih > 0.0) != 0);
+ if (__pyx_t_8) {
+
+ /* "nms.pyx":138
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1)
+ * if ih > 0:
+ * ua = float((tx2 - tx1 + 1) * (ty2 - ty1 + 1) + area - iw * ih) # <<<<<<<<<<<<<<
+ * ov = iw * ih / ua #iou between max box and detection box
+ *
+ */
+ __pyx_v_ua = ((double)(((((__pyx_v_tx2 - __pyx_v_tx1) + 1.0) * ((__pyx_v_ty2 - __pyx_v_ty1) + 1.0)) + __pyx_v_area) - (__pyx_v_iw * __pyx_v_ih)));
+
+ /* "nms.pyx":139
+ * if ih > 0:
+ * ua = float((tx2 - tx1 + 1) * (ty2 - ty1 + 1) + area - iw * ih)
+ * ov = iw * ih / ua #iou between max box and detection box # <<<<<<<<<<<<<<
+ *
+ * if method == 1: # linear
+ */
+ __pyx_t_6 = (__pyx_v_iw * __pyx_v_ih);
+ if (unlikely(__pyx_v_ua == 0)) {
+ PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+ __PYX_ERR(0, 139, __pyx_L1_error)
+ }
+ __pyx_v_ov = (__pyx_t_6 / __pyx_v_ua);
+
+ /* "nms.pyx":141
+ * ov = iw * ih / ua #iou between max box and detection box
+ *
+ * if method == 1: # linear # <<<<<<<<<<<<<<
+ * if ov > Nt:
+ * weight = 1 - ov
+ */
+ switch (__pyx_v_method) {
+ case 1:
+
+ /* "nms.pyx":142
+ *
+ * if method == 1: # linear
+ * if ov > Nt: # <<<<<<<<<<<<<<
+ * weight = 1 - ov
+ * else:
+ */
+ __pyx_t_8 = ((__pyx_v_ov > __pyx_v_Nt) != 0);
+ if (__pyx_t_8) {
+
+ /* "nms.pyx":143
+ * if method == 1: # linear
+ * if ov > Nt:
+ * weight = 1 - ov # <<<<<<<<<<<<<<
+ * else:
+ * weight = 1
+ */
+ __pyx_v_weight = (1.0 - __pyx_v_ov);
+
+ /* "nms.pyx":142
+ *
+ * if method == 1: # linear
+ * if ov > Nt: # <<<<<<<<<<<<<<
+ * weight = 1 - ov
+ * else:
+ */
+ goto __pyx_L12;
+ }
+
+ /* "nms.pyx":145
+ * weight = 1 - ov
+ * else:
+ * weight = 1 # <<<<<<<<<<<<<<
+ * elif method == 2: # gaussian
+ * weight = np.exp(-(ov * ov)/sigma)
+ */
+ /*else*/ {
+ __pyx_v_weight = 1.0;
+ }
+ __pyx_L12:;
+
+ /* "nms.pyx":141
+ * ov = iw * ih / ua #iou between max box and detection box
+ *
+ * if method == 1: # linear # <<<<<<<<<<<<<<
+ * if ov > Nt:
+ * weight = 1 - ov
+ */
+ break;
+ case 2:
+
+ /* "nms.pyx":147
+ * weight = 1
+ * elif method == 2: # gaussian
+ * weight = np.exp(-(ov * ov)/sigma) # <<<<<<<<<<<<<<
+ * else: # original NMS
+ * if ov > Nt:
+ */
+ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 147, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_43 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_exp); if (unlikely(!__pyx_t_43)) __PYX_ERR(0, 147, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_43);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = (-(__pyx_v_ov * __pyx_v_ov));
+ if (unlikely(__pyx_v_sigma == 0)) {
+ PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+ __PYX_ERR(0, 147, __pyx_L1_error)
+ }
+ __pyx_t_2 = PyFloat_FromDouble((__pyx_t_6 / __pyx_v_sigma)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 147, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_44 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_43))) {
+ __pyx_t_44 = PyMethod_GET_SELF(__pyx_t_43);
+ if (likely(__pyx_t_44)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_43);
+ __Pyx_INCREF(__pyx_t_44);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_43, function);
+ }
+ }
+ __pyx_t_5 = (__pyx_t_44) ? __Pyx_PyObject_Call2Args(__pyx_t_43, __pyx_t_44, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_43, __pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_44); __pyx_t_44 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 147, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_43); __pyx_t_43 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 147, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_weight = __pyx_t_6;
+
+ /* "nms.pyx":146
+ * else:
+ * weight = 1
+ * elif method == 2: # gaussian # <<<<<<<<<<<<<<
+ * weight = np.exp(-(ov * ov)/sigma)
+ * else: # original NMS
+ */
+ break;
+ default:
+
+ /* "nms.pyx":149
+ * weight = np.exp(-(ov * ov)/sigma)
+ * else: # original NMS
+ * if ov > Nt: # <<<<<<<<<<<<<<
+ * weight = 0
+ * else:
+ */
+ __pyx_t_8 = ((__pyx_v_ov > __pyx_v_Nt) != 0);
+ if (__pyx_t_8) {
+
+ /* "nms.pyx":150
+ * else: # original NMS
+ * if ov > Nt:
+ * weight = 0 # <<<<<<<<<<<<<<
+ * else:
+ * weight = 1
+ */
+ __pyx_v_weight = 0.0;
+
+ /* "nms.pyx":149
+ * weight = np.exp(-(ov * ov)/sigma)
+ * else: # original NMS
+ * if ov > Nt: # <<<<<<<<<<<<<<
+ * weight = 0
+ * else:
+ */
+ goto __pyx_L13;
+ }
+
+ /* "nms.pyx":152
+ * weight = 0
+ * else:
+ * weight = 1 # <<<<<<<<<<<<<<
+ *
+ * boxes[pos, 4] = weight*boxes[pos, 4]
+ */
+ /*else*/ {
+ __pyx_v_weight = 1.0;
+ }
+ __pyx_L13:;
+ break;
+ }
+
+ /* "nms.pyx":154
+ * weight = 1
+ *
+ * boxes[pos, 4] = weight*boxes[pos, 4] # <<<<<<<<<<<<<<
+ *
+ * # if box score falls below threshold, discard the box by swapping with last box
+ */
+ __pyx_t_45 = __pyx_v_pos;
+ __pyx_t_46 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_45 < 0) {
+ __pyx_t_45 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_45 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_45 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_46 < 0) {
+ __pyx_t_46 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_46 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_46 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 154, __pyx_L1_error)
+ }
+ __pyx_t_47 = __pyx_v_pos;
+ __pyx_t_48 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_47 < 0) {
+ __pyx_t_47 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_47 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_47 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_48 < 0) {
+ __pyx_t_48 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_48 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_48 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 154, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_47, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_48, __pyx_pybuffernd_boxes.diminfo[1].strides) = (__pyx_v_weight * (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_45, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_46, __pyx_pybuffernd_boxes.diminfo[1].strides)));
+
+ /* "nms.pyx":158
+ * # if box score falls below threshold, discard the box by swapping with last box
+ * # update N
+ * if boxes[pos, 4] < threshold: # <<<<<<<<<<<<<<
+ * boxes[pos,0] = boxes[N-1, 0]
+ * boxes[pos,1] = boxes[N-1, 1]
+ */
+ __pyx_t_49 = __pyx_v_pos;
+ __pyx_t_50 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_49 < 0) {
+ __pyx_t_49 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_49 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_49 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_50 < 0) {
+ __pyx_t_50 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_50 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_50 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 158, __pyx_L1_error)
+ }
+ __pyx_t_8 = (((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_49, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_50, __pyx_pybuffernd_boxes.diminfo[1].strides)) < __pyx_v_threshold) != 0);
+ if (__pyx_t_8) {
+
+ /* "nms.pyx":159
+ * # update N
+ * if boxes[pos, 4] < threshold:
+ * boxes[pos,0] = boxes[N-1, 0] # <<<<<<<<<<<<<<
+ * boxes[pos,1] = boxes[N-1, 1]
+ * boxes[pos,2] = boxes[N-1, 2]
+ */
+ __pyx_t_51 = (__pyx_v_N - 1);
+ __pyx_t_52 = 0;
+ __pyx_t_7 = -1;
+ if (__pyx_t_51 < 0) {
+ __pyx_t_51 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_51 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_51 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_52 < 0) {
+ __pyx_t_52 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_52 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_52 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 159, __pyx_L1_error)
+ }
+ __pyx_t_53 = __pyx_v_pos;
+ __pyx_t_54 = 0;
+ __pyx_t_7 = -1;
+ if (__pyx_t_53 < 0) {
+ __pyx_t_53 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_53 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_53 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_54 < 0) {
+ __pyx_t_54 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_54 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_54 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 159, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_53, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_54, __pyx_pybuffernd_boxes.diminfo[1].strides) = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_51, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_52, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":160
+ * if boxes[pos, 4] < threshold:
+ * boxes[pos,0] = boxes[N-1, 0]
+ * boxes[pos,1] = boxes[N-1, 1] # <<<<<<<<<<<<<<
+ * boxes[pos,2] = boxes[N-1, 2]
+ * boxes[pos,3] = boxes[N-1, 3]
+ */
+ __pyx_t_55 = (__pyx_v_N - 1);
+ __pyx_t_56 = 1;
+ __pyx_t_7 = -1;
+ if (__pyx_t_55 < 0) {
+ __pyx_t_55 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_55 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_55 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_56 < 0) {
+ __pyx_t_56 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_56 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_56 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 160, __pyx_L1_error)
+ }
+ __pyx_t_57 = __pyx_v_pos;
+ __pyx_t_58 = 1;
+ __pyx_t_7 = -1;
+ if (__pyx_t_57 < 0) {
+ __pyx_t_57 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_57 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_57 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_58 < 0) {
+ __pyx_t_58 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_58 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_58 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 160, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_57, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_58, __pyx_pybuffernd_boxes.diminfo[1].strides) = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_55, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_56, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":161
+ * boxes[pos,0] = boxes[N-1, 0]
+ * boxes[pos,1] = boxes[N-1, 1]
+ * boxes[pos,2] = boxes[N-1, 2] # <<<<<<<<<<<<<<
+ * boxes[pos,3] = boxes[N-1, 3]
+ * boxes[pos,4] = boxes[N-1, 4]
+ */
+ __pyx_t_59 = (__pyx_v_N - 1);
+ __pyx_t_60 = 2;
+ __pyx_t_7 = -1;
+ if (__pyx_t_59 < 0) {
+ __pyx_t_59 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_59 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_59 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_60 < 0) {
+ __pyx_t_60 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_60 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_60 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 161, __pyx_L1_error)
+ }
+ __pyx_t_61 = __pyx_v_pos;
+ __pyx_t_62 = 2;
+ __pyx_t_7 = -1;
+ if (__pyx_t_61 < 0) {
+ __pyx_t_61 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_61 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_61 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_62 < 0) {
+ __pyx_t_62 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_62 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_62 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 161, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_61, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_62, __pyx_pybuffernd_boxes.diminfo[1].strides) = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_59, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_60, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":162
+ * boxes[pos,1] = boxes[N-1, 1]
+ * boxes[pos,2] = boxes[N-1, 2]
+ * boxes[pos,3] = boxes[N-1, 3] # <<<<<<<<<<<<<<
+ * boxes[pos,4] = boxes[N-1, 4]
+ * N = N - 1
+ */
+ __pyx_t_63 = (__pyx_v_N - 1);
+ __pyx_t_64 = 3;
+ __pyx_t_7 = -1;
+ if (__pyx_t_63 < 0) {
+ __pyx_t_63 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_63 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_63 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_64 < 0) {
+ __pyx_t_64 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_64 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_64 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 162, __pyx_L1_error)
+ }
+ __pyx_t_65 = __pyx_v_pos;
+ __pyx_t_66 = 3;
+ __pyx_t_7 = -1;
+ if (__pyx_t_65 < 0) {
+ __pyx_t_65 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_65 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_65 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_66 < 0) {
+ __pyx_t_66 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_66 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_66 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 162, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_65, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_66, __pyx_pybuffernd_boxes.diminfo[1].strides) = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_63, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_64, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":163
+ * boxes[pos,2] = boxes[N-1, 2]
+ * boxes[pos,3] = boxes[N-1, 3]
+ * boxes[pos,4] = boxes[N-1, 4] # <<<<<<<<<<<<<<
+ * N = N - 1
+ * pos = pos - 1
+ */
+ __pyx_t_67 = (__pyx_v_N - 1);
+ __pyx_t_68 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_67 < 0) {
+ __pyx_t_67 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_67 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_67 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_68 < 0) {
+ __pyx_t_68 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_68 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_68 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 163, __pyx_L1_error)
+ }
+ __pyx_t_69 = __pyx_v_pos;
+ __pyx_t_70 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_69 < 0) {
+ __pyx_t_69 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_69 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_69 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_70 < 0) {
+ __pyx_t_70 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_70 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_70 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 163, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_69, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_70, __pyx_pybuffernd_boxes.diminfo[1].strides) = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_67, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_68, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":164
+ * boxes[pos,3] = boxes[N-1, 3]
+ * boxes[pos,4] = boxes[N-1, 4]
+ * N = N - 1 # <<<<<<<<<<<<<<
+ * pos = pos - 1
+ *
+ */
+ __pyx_v_N = (__pyx_v_N - 1);
+
+ /* "nms.pyx":165
+ * boxes[pos,4] = boxes[N-1, 4]
+ * N = N - 1
+ * pos = pos - 1 # <<<<<<<<<<<<<<
+ *
+ * pos = pos + 1
+ */
+ __pyx_v_pos = (__pyx_v_pos - 1);
+
+ /* "nms.pyx":158
+ * # if box score falls below threshold, discard the box by swapping with last box
+ * # update N
+ * if boxes[pos, 4] < threshold: # <<<<<<<<<<<<<<
+ * boxes[pos,0] = boxes[N-1, 0]
+ * boxes[pos,1] = boxes[N-1, 1]
+ */
+ }
+
+ /* "nms.pyx":137
+ * if iw > 0:
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1)
+ * if ih > 0: # <<<<<<<<<<<<<<
+ * ua = float((tx2 - tx1 + 1) * (ty2 - ty1 + 1) + area - iw * ih)
+ * ov = iw * ih / ua #iou between max box and detection box
+ */
+ }
+
+ /* "nms.pyx":135
+ * area = (x2 - x1 + 1) * (y2 - y1 + 1)
+ * iw = (min(tx2, x2) - max(tx1, x1) + 1)
+ * if iw > 0: # <<<<<<<<<<<<<<
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1)
+ * if ih > 0:
+ */
+ }
+
+ /* "nms.pyx":167
+ * pos = pos - 1
+ *
+ * pos = pos + 1 # <<<<<<<<<<<<<<
+ *
+ * keep = [i for i in range(N)]
+ */
+ __pyx_v_pos = (__pyx_v_pos + 1);
+ }
+
+ /* "nms.pyx":86
+ * cdef float x1,x2,y1,y2,tx1,tx2,ty1,ty2,ts,area,weight,ov
+ *
+ * for i in range(N): # <<<<<<<<<<<<<<
+ * maxscore = boxes[i, 4]
+ * maxpos = i
+ */
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "nms.pyx":169
+ * pos = pos + 1
+ *
+ * keep = [i for i in range(N)] # <<<<<<<<<<<<<<
+ * return keep
+ *
+ */
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 169, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_N); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 169, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_43 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_5); if (unlikely(!__pyx_t_43)) __PYX_ERR(0, 169, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_43);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ if (likely(PyList_CheckExact(__pyx_t_43)) || PyTuple_CheckExact(__pyx_t_43)) {
+ __pyx_t_5 = __pyx_t_43; __Pyx_INCREF(__pyx_t_5); __pyx_t_3 = 0;
+ __pyx_t_4 = NULL;
+ } else {
+ __pyx_t_3 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_43); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 169, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_4 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 169, __pyx_L1_error)
+ }
+ __Pyx_DECREF(__pyx_t_43); __pyx_t_43 = 0;
+ for (;;) {
+ if (likely(!__pyx_t_4)) {
+ if (likely(PyList_CheckExact(__pyx_t_5))) {
+ if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_5)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_43 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_3); __Pyx_INCREF(__pyx_t_43); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 169, __pyx_L1_error)
+ #else
+ __pyx_t_43 = PySequence_ITEM(__pyx_t_5, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_43)) __PYX_ERR(0, 169, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_43);
+ #endif
+ } else {
+ if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_5)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_43 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_3); __Pyx_INCREF(__pyx_t_43); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 169, __pyx_L1_error)
+ #else
+ __pyx_t_43 = PySequence_ITEM(__pyx_t_5, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_43)) __PYX_ERR(0, 169, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_43);
+ #endif
+ }
+ } else {
+ __pyx_t_43 = __pyx_t_4(__pyx_t_5);
+ if (unlikely(!__pyx_t_43)) {
+ PyObject* exc_type = PyErr_Occurred();
+ if (exc_type) {
+ if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+ else __PYX_ERR(0, 169, __pyx_L1_error)
+ }
+ break;
+ }
+ __Pyx_GOTREF(__pyx_t_43);
+ }
+ __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_43);
+ __pyx_t_43 = 0;
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_v_i))) __PYX_ERR(0, 169, __pyx_L1_error)
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_keep = ((PyObject*)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "nms.pyx":170
+ *
+ * keep = [i for i in range(N)]
+ * return keep # <<<<<<<<<<<<<<
+ *
+ * def soft_nms_39(np.ndarray[float, ndim=2] boxes, float sigma=0.5, float Nt=0.3, float threshold=0.001, unsigned int method=0):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(__pyx_v_keep);
+ __pyx_r = __pyx_v_keep;
+ goto __pyx_L0;
+
+ /* "nms.pyx":77
+ * return keep
+ *
+ * def soft_nms(np.ndarray[float, ndim=2] boxes, float sigma=0.5, float Nt=0.3, float threshold=0.001, unsigned int method=0): # <<<<<<<<<<<<<<
+ * cdef unsigned int N = boxes.shape[0]
+ * cdef float iw, ih, box_area
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_43);
+ __Pyx_XDECREF(__pyx_t_44);
+ { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
+ __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer);
+ __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+ __Pyx_AddTraceback("nms.soft_nms", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ goto __pyx_L2;
+ __pyx_L0:;
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer);
+ __pyx_L2:;
+ __Pyx_XDECREF(__pyx_v_i);
+ __Pyx_XDECREF(__pyx_v_s);
+ __Pyx_XDECREF(__pyx_v_keep);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "nms.pyx":172
+ * return keep
+ *
+ * def soft_nms_39(np.ndarray[float, ndim=2] boxes, float sigma=0.5, float Nt=0.3, float threshold=0.001, unsigned int method=0): # <<<<<<<<<<<<<<
+ * cdef unsigned int N = boxes.shape[0]
+ * cdef float iw, ih, box_area
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3nms_5soft_nms_39(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_3nms_5soft_nms_39 = {"soft_nms_39", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3nms_5soft_nms_39, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_3nms_5soft_nms_39(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyArrayObject *__pyx_v_boxes = 0;
+ float __pyx_v_sigma;
+ float __pyx_v_Nt;
+ float __pyx_v_threshold;
+ unsigned int __pyx_v_method;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("soft_nms_39 (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_boxes,&__pyx_n_s_sigma,&__pyx_n_s_Nt,&__pyx_n_s_threshold,&__pyx_n_s_method,0};
+ PyObject* values[5] = {0,0,0,0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ CYTHON_FALLTHROUGH;
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ CYTHON_FALLTHROUGH;
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ CYTHON_FALLTHROUGH;
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ CYTHON_FALLTHROUGH;
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ CYTHON_FALLTHROUGH;
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_boxes)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ CYTHON_FALLTHROUGH;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sigma);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ CYTHON_FALLTHROUGH;
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Nt);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ CYTHON_FALLTHROUGH;
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_threshold);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ CYTHON_FALLTHROUGH;
+ case 4:
+ if (kw_args > 0) {
+ PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_method);
+ if (value) { values[4] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "soft_nms_39") < 0)) __PYX_ERR(0, 172, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ CYTHON_FALLTHROUGH;
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ CYTHON_FALLTHROUGH;
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ CYTHON_FALLTHROUGH;
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ CYTHON_FALLTHROUGH;
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ __pyx_v_boxes = ((PyArrayObject *)values[0]);
+ if (values[1]) {
+ __pyx_v_sigma = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_sigma == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 172, __pyx_L3_error)
+ } else {
+ __pyx_v_sigma = ((float)0.5);
+ }
+ if (values[2]) {
+ __pyx_v_Nt = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_Nt == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 172, __pyx_L3_error)
+ } else {
+ __pyx_v_Nt = ((float)0.3);
+ }
+ if (values[3]) {
+ __pyx_v_threshold = __pyx_PyFloat_AsFloat(values[3]); if (unlikely((__pyx_v_threshold == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 172, __pyx_L3_error)
+ } else {
+ __pyx_v_threshold = ((float)0.001);
+ }
+ if (values[4]) {
+ __pyx_v_method = __Pyx_PyInt_As_unsigned_int(values[4]); if (unlikely((__pyx_v_method == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 172, __pyx_L3_error)
+ } else {
+ __pyx_v_method = ((unsigned int)0);
+ }
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("soft_nms_39", 0, 1, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 172, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("nms.soft_nms_39", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_boxes), __pyx_ptype_5numpy_ndarray, 1, "boxes", 0))) __PYX_ERR(0, 172, __pyx_L1_error)
+ __pyx_r = __pyx_pf_3nms_4soft_nms_39(__pyx_self, __pyx_v_boxes, __pyx_v_sigma, __pyx_v_Nt, __pyx_v_threshold, __pyx_v_method);
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3nms_4soft_nms_39(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, float __pyx_v_sigma, float __pyx_v_Nt, float __pyx_v_threshold, unsigned int __pyx_v_method) {
+ unsigned int __pyx_v_N;
+ float __pyx_v_iw;
+ float __pyx_v_ih;
+ float __pyx_v_ua;
+ int __pyx_v_pos;
+ float __pyx_v_maxscore;
+ int __pyx_v_maxpos;
+ float __pyx_v_x1;
+ float __pyx_v_x2;
+ float __pyx_v_y1;
+ float __pyx_v_y2;
+ float __pyx_v_tx1;
+ float __pyx_v_tx2;
+ float __pyx_v_ty1;
+ float __pyx_v_ty2;
+ float __pyx_v_ts;
+ float __pyx_v_area;
+ float __pyx_v_weight;
+ float __pyx_v_ov;
+ float __pyx_v_tmp;
+ PyObject *__pyx_v_i = NULL;
+ long __pyx_v_j;
+ CYTHON_UNUSED PyObject *__pyx_v_s = NULL;
+ PyObject *__pyx_v_keep = NULL;
+ __Pyx_LocalBuf_ND __pyx_pybuffernd_boxes;
+ __Pyx_Buffer __pyx_pybuffer_boxes;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ Py_ssize_t __pyx_t_3;
+ PyObject *(*__pyx_t_4)(PyObject *);
+ PyObject *__pyx_t_5 = NULL;
+ float __pyx_t_6;
+ int __pyx_t_7;
+ int __pyx_t_8;
+ Py_ssize_t __pyx_t_9;
+ Py_ssize_t __pyx_t_10;
+ Py_ssize_t __pyx_t_11;
+ Py_ssize_t __pyx_t_12;
+ Py_ssize_t __pyx_t_13;
+ Py_ssize_t __pyx_t_14;
+ Py_ssize_t __pyx_t_15;
+ Py_ssize_t __pyx_t_16;
+ Py_ssize_t __pyx_t_17;
+ Py_ssize_t __pyx_t_18;
+ Py_ssize_t __pyx_t_19;
+ Py_ssize_t __pyx_t_20;
+ Py_ssize_t __pyx_t_21;
+ Py_ssize_t __pyx_t_22;
+ Py_ssize_t __pyx_t_23;
+ Py_ssize_t __pyx_t_24;
+ Py_ssize_t __pyx_t_25;
+ Py_ssize_t __pyx_t_26;
+ Py_ssize_t __pyx_t_27;
+ Py_ssize_t __pyx_t_28;
+ Py_ssize_t __pyx_t_29;
+ Py_ssize_t __pyx_t_30;
+ Py_ssize_t __pyx_t_31;
+ Py_ssize_t __pyx_t_32;
+ long __pyx_t_33;
+ Py_ssize_t __pyx_t_34;
+ Py_ssize_t __pyx_t_35;
+ PyObject *__pyx_t_36 = NULL;
+ Py_ssize_t __pyx_t_37;
+ Py_ssize_t __pyx_t_38;
+ Py_ssize_t __pyx_t_39;
+ Py_ssize_t __pyx_t_40;
+ Py_ssize_t __pyx_t_41;
+ Py_ssize_t __pyx_t_42;
+ Py_ssize_t __pyx_t_43;
+ Py_ssize_t __pyx_t_44;
+ Py_ssize_t __pyx_t_45;
+ Py_ssize_t __pyx_t_46;
+ Py_ssize_t __pyx_t_47;
+ Py_ssize_t __pyx_t_48;
+ PyObject *__pyx_t_49 = NULL;
+ Py_ssize_t __pyx_t_50;
+ Py_ssize_t __pyx_t_51;
+ Py_ssize_t __pyx_t_52;
+ Py_ssize_t __pyx_t_53;
+ Py_ssize_t __pyx_t_54;
+ Py_ssize_t __pyx_t_55;
+ Py_ssize_t __pyx_t_56;
+ Py_ssize_t __pyx_t_57;
+ Py_ssize_t __pyx_t_58;
+ Py_ssize_t __pyx_t_59;
+ Py_ssize_t __pyx_t_60;
+ Py_ssize_t __pyx_t_61;
+ Py_ssize_t __pyx_t_62;
+ Py_ssize_t __pyx_t_63;
+ Py_ssize_t __pyx_t_64;
+ Py_ssize_t __pyx_t_65;
+ Py_ssize_t __pyx_t_66;
+ Py_ssize_t __pyx_t_67;
+ Py_ssize_t __pyx_t_68;
+ Py_ssize_t __pyx_t_69;
+ Py_ssize_t __pyx_t_70;
+ Py_ssize_t __pyx_t_71;
+ Py_ssize_t __pyx_t_72;
+ Py_ssize_t __pyx_t_73;
+ Py_ssize_t __pyx_t_74;
+ Py_ssize_t __pyx_t_75;
+ Py_ssize_t __pyx_t_76;
+ Py_ssize_t __pyx_t_77;
+ Py_ssize_t __pyx_t_78;
+ Py_ssize_t __pyx_t_79;
+ Py_ssize_t __pyx_t_80;
+ Py_ssize_t __pyx_t_81;
+ Py_ssize_t __pyx_t_82;
+ Py_ssize_t __pyx_t_83;
+ __Pyx_RefNannySetupContext("soft_nms_39", 0);
+ __pyx_pybuffer_boxes.pybuffer.buf = NULL;
+ __pyx_pybuffer_boxes.refcount = 0;
+ __pyx_pybuffernd_boxes.data = NULL;
+ __pyx_pybuffernd_boxes.rcbuffer = &__pyx_pybuffer_boxes;
+ {
+ __Pyx_BufFmt_StackElem __pyx_stack[1];
+ if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_boxes, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 172, __pyx_L1_error)
+ }
+ __pyx_pybuffernd_boxes.diminfo[0].strides = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_boxes.diminfo[0].shape = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_boxes.diminfo[1].strides = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_boxes.diminfo[1].shape = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.shape[1];
+
+ /* "nms.pyx":173
+ *
+ * def soft_nms_39(np.ndarray[float, ndim=2] boxes, float sigma=0.5, float Nt=0.3, float threshold=0.001, unsigned int method=0):
+ * cdef unsigned int N = boxes.shape[0] # <<<<<<<<<<<<<<
+ * cdef float iw, ih, box_area
+ * cdef float ua
+ */
+ __pyx_v_N = (__pyx_v_boxes->dimensions[0]);
+
+ /* "nms.pyx":176
+ * cdef float iw, ih, box_area
+ * cdef float ua
+ * cdef int pos = 0 # <<<<<<<<<<<<<<
+ * cdef float maxscore = 0
+ * cdef int maxpos = 0
+ */
+ __pyx_v_pos = 0;
+
+ /* "nms.pyx":177
+ * cdef float ua
+ * cdef int pos = 0
+ * cdef float maxscore = 0 # <<<<<<<<<<<<<<
+ * cdef int maxpos = 0
+ * cdef float x1,x2,y1,y2,tx1,tx2,ty1,ty2,ts,area,weight,ov
+ */
+ __pyx_v_maxscore = 0.0;
+
+ /* "nms.pyx":178
+ * cdef int pos = 0
+ * cdef float maxscore = 0
+ * cdef int maxpos = 0 # <<<<<<<<<<<<<<
+ * cdef float x1,x2,y1,y2,tx1,tx2,ty1,ty2,ts,area,weight,ov
+ * cdef float tmp
+ */
+ __pyx_v_maxpos = 0;
+
+ /* "nms.pyx":182
+ * cdef float tmp
+ *
+ * for i in range(N): # <<<<<<<<<<<<<<
+ * maxscore = boxes[i, 4]
+ * maxpos = i
+ */
+ __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_N); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 182, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 182, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
+ __pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); __pyx_t_3 = 0;
+ __pyx_t_4 = NULL;
+ } else {
+ __pyx_t_3 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 182, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_4 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 182, __pyx_L1_error)
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ for (;;) {
+ if (likely(!__pyx_t_4)) {
+ if (likely(PyList_CheckExact(__pyx_t_1))) {
+ if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_1)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_3); __Pyx_INCREF(__pyx_t_2); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 182, __pyx_L1_error)
+ #else
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 182, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ #endif
+ } else {
+ if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_3); __Pyx_INCREF(__pyx_t_2); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 182, __pyx_L1_error)
+ #else
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 182, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ #endif
+ }
+ } else {
+ __pyx_t_2 = __pyx_t_4(__pyx_t_1);
+ if (unlikely(!__pyx_t_2)) {
+ PyObject* exc_type = PyErr_Occurred();
+ if (exc_type) {
+ if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+ else __PYX_ERR(0, 182, __pyx_L1_error)
+ }
+ break;
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ }
+ __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2);
+ __pyx_t_2 = 0;
+
+ /* "nms.pyx":183
+ *
+ * for i in range(N):
+ * maxscore = boxes[i, 4] # <<<<<<<<<<<<<<
+ * maxpos = i
+ *
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 183, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_4);
+ __Pyx_GIVEREF(__pyx_int_4);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_4);
+ __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 183, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 183, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_maxscore = __pyx_t_6;
+
+ /* "nms.pyx":184
+ * for i in range(N):
+ * maxscore = boxes[i, 4]
+ * maxpos = i # <<<<<<<<<<<<<<
+ *
+ * tx1 = boxes[i,0]
+ */
+ __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_i); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 184, __pyx_L1_error)
+ __pyx_v_maxpos = __pyx_t_7;
+
+ /* "nms.pyx":186
+ * maxpos = i
+ *
+ * tx1 = boxes[i,0] # <<<<<<<<<<<<<<
+ * ty1 = boxes[i,1]
+ * tx2 = boxes[i,2]
+ */
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 186, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_0);
+ __Pyx_GIVEREF(__pyx_int_0);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_0);
+ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 186, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 186, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_tx1 = __pyx_t_6;
+
+ /* "nms.pyx":187
+ *
+ * tx1 = boxes[i,0]
+ * ty1 = boxes[i,1] # <<<<<<<<<<<<<<
+ * tx2 = boxes[i,2]
+ * ty2 = boxes[i,3]
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 187, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_1);
+ __Pyx_GIVEREF(__pyx_int_1);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_1);
+ __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 187, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 187, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_ty1 = __pyx_t_6;
+
+ /* "nms.pyx":188
+ * tx1 = boxes[i,0]
+ * ty1 = boxes[i,1]
+ * tx2 = boxes[i,2] # <<<<<<<<<<<<<<
+ * ty2 = boxes[i,3]
+ * ts = boxes[i,4]
+ */
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 188, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_2);
+ __Pyx_GIVEREF(__pyx_int_2);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_2);
+ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 188, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 188, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_tx2 = __pyx_t_6;
+
+ /* "nms.pyx":189
+ * ty1 = boxes[i,1]
+ * tx2 = boxes[i,2]
+ * ty2 = boxes[i,3] # <<<<<<<<<<<<<<
+ * ts = boxes[i,4]
+ *
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 189, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_3);
+ __Pyx_GIVEREF(__pyx_int_3);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_3);
+ __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 189, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 189, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_ty2 = __pyx_t_6;
+
+ /* "nms.pyx":190
+ * tx2 = boxes[i,2]
+ * ty2 = boxes[i,3]
+ * ts = boxes[i,4] # <<<<<<<<<<<<<<
+ *
+ * pos = i + 1
+ */
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 190, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_4);
+ __Pyx_GIVEREF(__pyx_int_4);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_4);
+ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 190, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 190, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_ts = __pyx_t_6;
+
+ /* "nms.pyx":192
+ * ts = boxes[i,4]
+ *
+ * pos = i + 1 # <<<<<<<<<<<<<<
+ * # get max box
+ * while pos < N:
+ */
+ __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_v_i, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 192, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 192, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_pos = __pyx_t_7;
+
+ /* "nms.pyx":194
+ * pos = i + 1
+ * # get max box
+ * while pos < N: # <<<<<<<<<<<<<<
+ * if maxscore < boxes[pos, 4]:
+ * maxscore = boxes[pos, 4]
+ */
+ while (1) {
+ __pyx_t_8 = ((__pyx_v_pos < __pyx_v_N) != 0);
+ if (!__pyx_t_8) break;
+
+ /* "nms.pyx":195
+ * # get max box
+ * while pos < N:
+ * if maxscore < boxes[pos, 4]: # <<<<<<<<<<<<<<
+ * maxscore = boxes[pos, 4]
+ * maxpos = pos
+ */
+ __pyx_t_9 = __pyx_v_pos;
+ __pyx_t_10 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_9 < 0) {
+ __pyx_t_9 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_9 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_9 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_10 < 0) {
+ __pyx_t_10 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_10 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_10 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 195, __pyx_L1_error)
+ }
+ __pyx_t_8 = ((__pyx_v_maxscore < (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_9, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_10, __pyx_pybuffernd_boxes.diminfo[1].strides))) != 0);
+ if (__pyx_t_8) {
+
+ /* "nms.pyx":196
+ * while pos < N:
+ * if maxscore < boxes[pos, 4]:
+ * maxscore = boxes[pos, 4] # <<<<<<<<<<<<<<
+ * maxpos = pos
+ * pos = pos + 1
+ */
+ __pyx_t_11 = __pyx_v_pos;
+ __pyx_t_12 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_11 < 0) {
+ __pyx_t_11 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_11 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_11 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_12 < 0) {
+ __pyx_t_12 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_12 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_12 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 196, __pyx_L1_error)
+ }
+ __pyx_v_maxscore = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_12, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":197
+ * if maxscore < boxes[pos, 4]:
+ * maxscore = boxes[pos, 4]
+ * maxpos = pos # <<<<<<<<<<<<<<
+ * pos = pos + 1
+ *
+ */
+ __pyx_v_maxpos = __pyx_v_pos;
+
+ /* "nms.pyx":195
+ * # get max box
+ * while pos < N:
+ * if maxscore < boxes[pos, 4]: # <<<<<<<<<<<<<<
+ * maxscore = boxes[pos, 4]
+ * maxpos = pos
+ */
+ }
+
+ /* "nms.pyx":198
+ * maxscore = boxes[pos, 4]
+ * maxpos = pos
+ * pos = pos + 1 # <<<<<<<<<<<<<<
+ *
+ * # add max box as a detection
+ */
+ __pyx_v_pos = (__pyx_v_pos + 1);
+ }
+
+ /* "nms.pyx":201
+ *
+ * # add max box as a detection
+ * boxes[i,0] = boxes[maxpos,0] # <<<<<<<<<<<<<<
+ * boxes[i,1] = boxes[maxpos,1]
+ * boxes[i,2] = boxes[maxpos,2]
+ */
+ __pyx_t_13 = __pyx_v_maxpos;
+ __pyx_t_14 = 0;
+ __pyx_t_7 = -1;
+ if (__pyx_t_13 < 0) {
+ __pyx_t_13 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_13 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_13 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_14 < 0) {
+ __pyx_t_14 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_14 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_14 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 201, __pyx_L1_error)
+ }
+ __pyx_t_2 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_14, __pyx_pybuffernd_boxes.diminfo[1].strides))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 201, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 201, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_0);
+ __Pyx_GIVEREF(__pyx_int_0);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_0);
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5, __pyx_t_2) < 0)) __PYX_ERR(0, 201, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "nms.pyx":202
+ * # add max box as a detection
+ * boxes[i,0] = boxes[maxpos,0]
+ * boxes[i,1] = boxes[maxpos,1] # <<<<<<<<<<<<<<
+ * boxes[i,2] = boxes[maxpos,2]
+ * boxes[i,3] = boxes[maxpos,3]
+ */
+ __pyx_t_15 = __pyx_v_maxpos;
+ __pyx_t_16 = 1;
+ __pyx_t_7 = -1;
+ if (__pyx_t_15 < 0) {
+ __pyx_t_15 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_15 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_15 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_16 < 0) {
+ __pyx_t_16 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_16 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_16 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 202, __pyx_L1_error)
+ }
+ __pyx_t_2 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_16, __pyx_pybuffernd_boxes.diminfo[1].strides))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 202, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 202, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_1);
+ __Pyx_GIVEREF(__pyx_int_1);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_1);
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5, __pyx_t_2) < 0)) __PYX_ERR(0, 202, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "nms.pyx":203
+ * boxes[i,0] = boxes[maxpos,0]
+ * boxes[i,1] = boxes[maxpos,1]
+ * boxes[i,2] = boxes[maxpos,2] # <<<<<<<<<<<<<<
+ * boxes[i,3] = boxes[maxpos,3]
+ * boxes[i,4] = boxes[maxpos,4]
+ */
+ __pyx_t_17 = __pyx_v_maxpos;
+ __pyx_t_18 = 2;
+ __pyx_t_7 = -1;
+ if (__pyx_t_17 < 0) {
+ __pyx_t_17 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_17 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_18 < 0) {
+ __pyx_t_18 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_18 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_18 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 203, __pyx_L1_error)
+ }
+ __pyx_t_2 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_18, __pyx_pybuffernd_boxes.diminfo[1].strides))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 203, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 203, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_2);
+ __Pyx_GIVEREF(__pyx_int_2);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_2);
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5, __pyx_t_2) < 0)) __PYX_ERR(0, 203, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "nms.pyx":204
+ * boxes[i,1] = boxes[maxpos,1]
+ * boxes[i,2] = boxes[maxpos,2]
+ * boxes[i,3] = boxes[maxpos,3] # <<<<<<<<<<<<<<
+ * boxes[i,4] = boxes[maxpos,4]
+ *
+ */
+ __pyx_t_19 = __pyx_v_maxpos;
+ __pyx_t_20 = 3;
+ __pyx_t_7 = -1;
+ if (__pyx_t_19 < 0) {
+ __pyx_t_19 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_19 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_19 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_20 < 0) {
+ __pyx_t_20 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_20 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 204, __pyx_L1_error)
+ }
+ __pyx_t_2 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_19, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_20, __pyx_pybuffernd_boxes.diminfo[1].strides))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 204, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 204, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_3);
+ __Pyx_GIVEREF(__pyx_int_3);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_3);
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5, __pyx_t_2) < 0)) __PYX_ERR(0, 204, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "nms.pyx":205
+ * boxes[i,2] = boxes[maxpos,2]
+ * boxes[i,3] = boxes[maxpos,3]
+ * boxes[i,4] = boxes[maxpos,4] # <<<<<<<<<<<<<<
+ *
+ * # swap ith box with position of max box
+ */
+ __pyx_t_21 = __pyx_v_maxpos;
+ __pyx_t_22 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_21 < 0) {
+ __pyx_t_21 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_21 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_21 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_22 < 0) {
+ __pyx_t_22 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_22 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_22 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 205, __pyx_L1_error)
+ }
+ __pyx_t_2 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_21, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_22, __pyx_pybuffernd_boxes.diminfo[1].strides))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 205, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 205, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_4);
+ __Pyx_GIVEREF(__pyx_int_4);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_4);
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5, __pyx_t_2) < 0)) __PYX_ERR(0, 205, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "nms.pyx":208
+ *
+ * # swap ith box with position of max box
+ * boxes[maxpos,0] = tx1 # <<<<<<<<<<<<<<
+ * boxes[maxpos,1] = ty1
+ * boxes[maxpos,2] = tx2
+ */
+ __pyx_t_23 = __pyx_v_maxpos;
+ __pyx_t_24 = 0;
+ __pyx_t_7 = -1;
+ if (__pyx_t_23 < 0) {
+ __pyx_t_23 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_23 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_23 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_24 < 0) {
+ __pyx_t_24 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_24 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_24 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 208, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_23, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_24, __pyx_pybuffernd_boxes.diminfo[1].strides) = __pyx_v_tx1;
+
+ /* "nms.pyx":209
+ * # swap ith box with position of max box
+ * boxes[maxpos,0] = tx1
+ * boxes[maxpos,1] = ty1 # <<<<<<<<<<<<<<
+ * boxes[maxpos,2] = tx2
+ * boxes[maxpos,3] = ty2
+ */
+ __pyx_t_25 = __pyx_v_maxpos;
+ __pyx_t_26 = 1;
+ __pyx_t_7 = -1;
+ if (__pyx_t_25 < 0) {
+ __pyx_t_25 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_25 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_25 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_26 < 0) {
+ __pyx_t_26 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_26 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_26 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 209, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_25, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_26, __pyx_pybuffernd_boxes.diminfo[1].strides) = __pyx_v_ty1;
+
+ /* "nms.pyx":210
+ * boxes[maxpos,0] = tx1
+ * boxes[maxpos,1] = ty1
+ * boxes[maxpos,2] = tx2 # <<<<<<<<<<<<<<
+ * boxes[maxpos,3] = ty2
+ * boxes[maxpos,4] = ts
+ */
+ __pyx_t_27 = __pyx_v_maxpos;
+ __pyx_t_28 = 2;
+ __pyx_t_7 = -1;
+ if (__pyx_t_27 < 0) {
+ __pyx_t_27 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_27 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_27 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_28 < 0) {
+ __pyx_t_28 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_28 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_28 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 210, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_27, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_28, __pyx_pybuffernd_boxes.diminfo[1].strides) = __pyx_v_tx2;
+
+ /* "nms.pyx":211
+ * boxes[maxpos,1] = ty1
+ * boxes[maxpos,2] = tx2
+ * boxes[maxpos,3] = ty2 # <<<<<<<<<<<<<<
+ * boxes[maxpos,4] = ts
+ *
+ */
+ __pyx_t_29 = __pyx_v_maxpos;
+ __pyx_t_30 = 3;
+ __pyx_t_7 = -1;
+ if (__pyx_t_29 < 0) {
+ __pyx_t_29 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_29 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_29 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_30 < 0) {
+ __pyx_t_30 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_30 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_30 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 211, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_29, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_30, __pyx_pybuffernd_boxes.diminfo[1].strides) = __pyx_v_ty2;
+
+ /* "nms.pyx":212
+ * boxes[maxpos,2] = tx2
+ * boxes[maxpos,3] = ty2
+ * boxes[maxpos,4] = ts # <<<<<<<<<<<<<<
+ *
+ * for j in range(5, 39):
+ */
+ __pyx_t_31 = __pyx_v_maxpos;
+ __pyx_t_32 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_31 < 0) {
+ __pyx_t_31 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_31 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_31 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_32 < 0) {
+ __pyx_t_32 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_32 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_32 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 212, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_31, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_32, __pyx_pybuffernd_boxes.diminfo[1].strides) = __pyx_v_ts;
+
+ /* "nms.pyx":214
+ * boxes[maxpos,4] = ts
+ *
+ * for j in range(5, 39): # <<<<<<<<<<<<<<
+ * tmp = boxes[i, j]
+ * boxes[i, j] = boxes[maxpos, j]
+ */
+ for (__pyx_t_33 = 5; __pyx_t_33 < 39; __pyx_t_33+=1) {
+ __pyx_v_j = __pyx_t_33;
+
+ /* "nms.pyx":215
+ *
+ * for j in range(5, 39):
+ * tmp = boxes[i, j] # <<<<<<<<<<<<<<
+ * boxes[i, j] = boxes[maxpos, j]
+ * boxes[maxpos, j] = tmp
+ */
+ __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v_j); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 215, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 215, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_GIVEREF(__pyx_t_2);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2);
+ __pyx_t_2 = 0;
+ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 215, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 215, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_tmp = __pyx_t_6;
+
+ /* "nms.pyx":216
+ * for j in range(5, 39):
+ * tmp = boxes[i, j]
+ * boxes[i, j] = boxes[maxpos, j] # <<<<<<<<<<<<<<
+ * boxes[maxpos, j] = tmp
+ *
+ */
+ __pyx_t_34 = __pyx_v_maxpos;
+ __pyx_t_35 = __pyx_v_j;
+ __pyx_t_7 = -1;
+ if (__pyx_t_34 < 0) {
+ __pyx_t_34 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_34 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_34 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_35 < 0) {
+ __pyx_t_35 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_35 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_35 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 216, __pyx_L1_error)
+ }
+ __pyx_t_2 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_34, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_35, __pyx_pybuffernd_boxes.diminfo[1].strides))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 216, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = __Pyx_PyInt_From_long(__pyx_v_j); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 216, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_36 = PyTuple_New(2); if (unlikely(!__pyx_t_36)) __PYX_ERR(0, 216, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_36);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_36, 0, __pyx_v_i);
+ __Pyx_GIVEREF(__pyx_t_5);
+ PyTuple_SET_ITEM(__pyx_t_36, 1, __pyx_t_5);
+ __pyx_t_5 = 0;
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_boxes), __pyx_t_36, __pyx_t_2) < 0)) __PYX_ERR(0, 216, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_36); __pyx_t_36 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "nms.pyx":217
+ * tmp = boxes[i, j]
+ * boxes[i, j] = boxes[maxpos, j]
+ * boxes[maxpos, j] = tmp # <<<<<<<<<<<<<<
+ *
+ * tx1 = boxes[i,0]
+ */
+ __pyx_t_37 = __pyx_v_maxpos;
+ __pyx_t_38 = __pyx_v_j;
+ __pyx_t_7 = -1;
+ if (__pyx_t_37 < 0) {
+ __pyx_t_37 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_37 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_37 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_38 < 0) {
+ __pyx_t_38 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_38 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_38 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 217, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_37, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_38, __pyx_pybuffernd_boxes.diminfo[1].strides) = __pyx_v_tmp;
+ }
+
+ /* "nms.pyx":219
+ * boxes[maxpos, j] = tmp
+ *
+ * tx1 = boxes[i,0] # <<<<<<<<<<<<<<
+ * ty1 = boxes[i,1]
+ * tx2 = boxes[i,2]
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 219, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_0);
+ __Pyx_GIVEREF(__pyx_int_0);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_0);
+ __pyx_t_36 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_36)) __PYX_ERR(0, 219, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_36);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_36); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 219, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_36); __pyx_t_36 = 0;
+ __pyx_v_tx1 = __pyx_t_6;
+
+ /* "nms.pyx":220
+ *
+ * tx1 = boxes[i,0]
+ * ty1 = boxes[i,1] # <<<<<<<<<<<<<<
+ * tx2 = boxes[i,2]
+ * ty2 = boxes[i,3]
+ */
+ __pyx_t_36 = PyTuple_New(2); if (unlikely(!__pyx_t_36)) __PYX_ERR(0, 220, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_36);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_36, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_1);
+ __Pyx_GIVEREF(__pyx_int_1);
+ PyTuple_SET_ITEM(__pyx_t_36, 1, __pyx_int_1);
+ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_36); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 220, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_36); __pyx_t_36 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 220, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_ty1 = __pyx_t_6;
+
+ /* "nms.pyx":221
+ * tx1 = boxes[i,0]
+ * ty1 = boxes[i,1]
+ * tx2 = boxes[i,2] # <<<<<<<<<<<<<<
+ * ty2 = boxes[i,3]
+ * ts = boxes[i,4]
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 221, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_2);
+ __Pyx_GIVEREF(__pyx_int_2);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_2);
+ __pyx_t_36 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_36)) __PYX_ERR(0, 221, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_36);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_36); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 221, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_36); __pyx_t_36 = 0;
+ __pyx_v_tx2 = __pyx_t_6;
+
+ /* "nms.pyx":222
+ * ty1 = boxes[i,1]
+ * tx2 = boxes[i,2]
+ * ty2 = boxes[i,3] # <<<<<<<<<<<<<<
+ * ts = boxes[i,4]
+ *
+ */
+ __pyx_t_36 = PyTuple_New(2); if (unlikely(!__pyx_t_36)) __PYX_ERR(0, 222, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_36);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_36, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_3);
+ __Pyx_GIVEREF(__pyx_int_3);
+ PyTuple_SET_ITEM(__pyx_t_36, 1, __pyx_int_3);
+ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_36); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 222, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_36); __pyx_t_36 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 222, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_ty2 = __pyx_t_6;
+
+ /* "nms.pyx":223
+ * tx2 = boxes[i,2]
+ * ty2 = boxes[i,3]
+ * ts = boxes[i,4] # <<<<<<<<<<<<<<
+ *
+ * pos = i + 1
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 223, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_4);
+ __Pyx_GIVEREF(__pyx_int_4);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_4);
+ __pyx_t_36 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_36)) __PYX_ERR(0, 223, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_36);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_36); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 223, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_36); __pyx_t_36 = 0;
+ __pyx_v_ts = __pyx_t_6;
+
+ /* "nms.pyx":225
+ * ts = boxes[i,4]
+ *
+ * pos = i + 1 # <<<<<<<<<<<<<<
+ * # NMS iterations, note that N changes if detection boxes fall below threshold
+ * while pos < N:
+ */
+ __pyx_t_36 = __Pyx_PyInt_AddObjC(__pyx_v_i, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_36)) __PYX_ERR(0, 225, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_36);
+ __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_36); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 225, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_36); __pyx_t_36 = 0;
+ __pyx_v_pos = __pyx_t_7;
+
+ /* "nms.pyx":227
+ * pos = i + 1
+ * # NMS iterations, note that N changes if detection boxes fall below threshold
+ * while pos < N: # <<<<<<<<<<<<<<
+ * x1 = boxes[pos, 0]
+ * y1 = boxes[pos, 1]
+ */
+ while (1) {
+ __pyx_t_8 = ((__pyx_v_pos < __pyx_v_N) != 0);
+ if (!__pyx_t_8) break;
+
+ /* "nms.pyx":228
+ * # NMS iterations, note that N changes if detection boxes fall below threshold
+ * while pos < N:
+ * x1 = boxes[pos, 0] # <<<<<<<<<<<<<<
+ * y1 = boxes[pos, 1]
+ * x2 = boxes[pos, 2]
+ */
+ __pyx_t_39 = __pyx_v_pos;
+ __pyx_t_40 = 0;
+ __pyx_t_7 = -1;
+ if (__pyx_t_39 < 0) {
+ __pyx_t_39 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_39 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_39 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_40 < 0) {
+ __pyx_t_40 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_40 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_40 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 228, __pyx_L1_error)
+ }
+ __pyx_v_x1 = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_39, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_40, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":229
+ * while pos < N:
+ * x1 = boxes[pos, 0]
+ * y1 = boxes[pos, 1] # <<<<<<<<<<<<<<
+ * x2 = boxes[pos, 2]
+ * y2 = boxes[pos, 3]
+ */
+ __pyx_t_41 = __pyx_v_pos;
+ __pyx_t_42 = 1;
+ __pyx_t_7 = -1;
+ if (__pyx_t_41 < 0) {
+ __pyx_t_41 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_41 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_41 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_42 < 0) {
+ __pyx_t_42 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_42 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_42 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 229, __pyx_L1_error)
+ }
+ __pyx_v_y1 = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_41, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_42, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":230
+ * x1 = boxes[pos, 0]
+ * y1 = boxes[pos, 1]
+ * x2 = boxes[pos, 2] # <<<<<<<<<<<<<<
+ * y2 = boxes[pos, 3]
+ * s = boxes[pos, 4]
+ */
+ __pyx_t_43 = __pyx_v_pos;
+ __pyx_t_44 = 2;
+ __pyx_t_7 = -1;
+ if (__pyx_t_43 < 0) {
+ __pyx_t_43 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_43 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_43 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_44 < 0) {
+ __pyx_t_44 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_44 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_44 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 230, __pyx_L1_error)
+ }
+ __pyx_v_x2 = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_43, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_44, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":231
+ * y1 = boxes[pos, 1]
+ * x2 = boxes[pos, 2]
+ * y2 = boxes[pos, 3] # <<<<<<<<<<<<<<
+ * s = boxes[pos, 4]
+ *
+ */
+ __pyx_t_45 = __pyx_v_pos;
+ __pyx_t_46 = 3;
+ __pyx_t_7 = -1;
+ if (__pyx_t_45 < 0) {
+ __pyx_t_45 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_45 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_45 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_46 < 0) {
+ __pyx_t_46 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_46 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_46 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 231, __pyx_L1_error)
+ }
+ __pyx_v_y2 = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_45, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_46, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":232
+ * x2 = boxes[pos, 2]
+ * y2 = boxes[pos, 3]
+ * s = boxes[pos, 4] # <<<<<<<<<<<<<<
+ *
+ * area = (x2 - x1 + 1) * (y2 - y1 + 1)
+ */
+ __pyx_t_47 = __pyx_v_pos;
+ __pyx_t_48 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_47 < 0) {
+ __pyx_t_47 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_47 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_47 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_48 < 0) {
+ __pyx_t_48 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_48 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_48 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 232, __pyx_L1_error)
+ }
+ __pyx_t_36 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_47, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_48, __pyx_pybuffernd_boxes.diminfo[1].strides))); if (unlikely(!__pyx_t_36)) __PYX_ERR(0, 232, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_36);
+ __Pyx_XDECREF_SET(__pyx_v_s, __pyx_t_36);
+ __pyx_t_36 = 0;
+
+ /* "nms.pyx":234
+ * s = boxes[pos, 4]
+ *
+ * area = (x2 - x1 + 1) * (y2 - y1 + 1) # <<<<<<<<<<<<<<
+ * iw = (min(tx2, x2) - max(tx1, x1) + 1)
+ * if iw > 0:
+ */
+ __pyx_v_area = (((__pyx_v_x2 - __pyx_v_x1) + 1.0) * ((__pyx_v_y2 - __pyx_v_y1) + 1.0));
+
+ /* "nms.pyx":235
+ *
+ * area = (x2 - x1 + 1) * (y2 - y1 + 1)
+ * iw = (min(tx2, x2) - max(tx1, x1) + 1) # <<<<<<<<<<<<<<
+ * if iw > 0:
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1)
+ */
+ __pyx_v_iw = ((__pyx_f_3nms_min(__pyx_v_tx2, __pyx_v_x2) - __pyx_f_3nms_max(__pyx_v_tx1, __pyx_v_x1)) + 1.0);
+
+ /* "nms.pyx":236
+ * area = (x2 - x1 + 1) * (y2 - y1 + 1)
+ * iw = (min(tx2, x2) - max(tx1, x1) + 1)
+ * if iw > 0: # <<<<<<<<<<<<<<
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1)
+ * if ih > 0:
+ */
+ __pyx_t_8 = ((__pyx_v_iw > 0.0) != 0);
+ if (__pyx_t_8) {
+
+ /* "nms.pyx":237
+ * iw = (min(tx2, x2) - max(tx1, x1) + 1)
+ * if iw > 0:
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1) # <<<<<<<<<<<<<<
+ * if ih > 0:
+ * ua = float((tx2 - tx1 + 1) * (ty2 - ty1 + 1) + area - iw * ih)
+ */
+ __pyx_v_ih = ((__pyx_f_3nms_min(__pyx_v_ty2, __pyx_v_y2) - __pyx_f_3nms_max(__pyx_v_ty1, __pyx_v_y1)) + 1.0);
+
+ /* "nms.pyx":238
+ * if iw > 0:
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1)
+ * if ih > 0: # <<<<<<<<<<<<<<
+ * ua = float((tx2 - tx1 + 1) * (ty2 - ty1 + 1) + area - iw * ih)
+ * ov = iw * ih / ua #iou between max box and detection box
+ */
+ __pyx_t_8 = ((__pyx_v_ih > 0.0) != 0);
+ if (__pyx_t_8) {
+
+ /* "nms.pyx":239
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1)
+ * if ih > 0:
+ * ua = float((tx2 - tx1 + 1) * (ty2 - ty1 + 1) + area - iw * ih) # <<<<<<<<<<<<<<
+ * ov = iw * ih / ua #iou between max box and detection box
+ *
+ */
+ __pyx_v_ua = ((double)(((((__pyx_v_tx2 - __pyx_v_tx1) + 1.0) * ((__pyx_v_ty2 - __pyx_v_ty1) + 1.0)) + __pyx_v_area) - (__pyx_v_iw * __pyx_v_ih)));
+
+ /* "nms.pyx":240
+ * if ih > 0:
+ * ua = float((tx2 - tx1 + 1) * (ty2 - ty1 + 1) + area - iw * ih)
+ * ov = iw * ih / ua #iou between max box and detection box # <<<<<<<<<<<<<<
+ *
+ * if method == 1: # linear
+ */
+ __pyx_t_6 = (__pyx_v_iw * __pyx_v_ih);
+ if (unlikely(__pyx_v_ua == 0)) {
+ PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+ __PYX_ERR(0, 240, __pyx_L1_error)
+ }
+ __pyx_v_ov = (__pyx_t_6 / __pyx_v_ua);
+
+ /* "nms.pyx":242
+ * ov = iw * ih / ua #iou between max box and detection box
+ *
+ * if method == 1: # linear # <<<<<<<<<<<<<<
+ * if ov > Nt:
+ * weight = 1 - ov
+ */
+ switch (__pyx_v_method) {
+ case 1:
+
+ /* "nms.pyx":243
+ *
+ * if method == 1: # linear
+ * if ov > Nt: # <<<<<<<<<<<<<<
+ * weight = 1 - ov
+ * else:
+ */
+ __pyx_t_8 = ((__pyx_v_ov > __pyx_v_Nt) != 0);
+ if (__pyx_t_8) {
+
+ /* "nms.pyx":244
+ * if method == 1: # linear
+ * if ov > Nt:
+ * weight = 1 - ov # <<<<<<<<<<<<<<
+ * else:
+ * weight = 1
+ */
+ __pyx_v_weight = (1.0 - __pyx_v_ov);
+
+ /* "nms.pyx":243
+ *
+ * if method == 1: # linear
+ * if ov > Nt: # <<<<<<<<<<<<<<
+ * weight = 1 - ov
+ * else:
+ */
+ goto __pyx_L14;
+ }
+
+ /* "nms.pyx":246
+ * weight = 1 - ov
+ * else:
+ * weight = 1 # <<<<<<<<<<<<<<
+ * elif method == 2: # gaussian
+ * weight = np.exp(-(ov * ov)/sigma)
+ */
+ /*else*/ {
+ __pyx_v_weight = 1.0;
+ }
+ __pyx_L14:;
+
+ /* "nms.pyx":242
+ * ov = iw * ih / ua #iou between max box and detection box
+ *
+ * if method == 1: # linear # <<<<<<<<<<<<<<
+ * if ov > Nt:
+ * weight = 1 - ov
+ */
+ break;
+ case 2:
+
+ /* "nms.pyx":248
+ * weight = 1
+ * elif method == 2: # gaussian
+ * weight = np.exp(-(ov * ov)/sigma) # <<<<<<<<<<<<<<
+ * else: # original NMS
+ * if ov > Nt:
+ */
+ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 248, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_exp); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 248, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = (-(__pyx_v_ov * __pyx_v_ov));
+ if (unlikely(__pyx_v_sigma == 0)) {
+ PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+ __PYX_ERR(0, 248, __pyx_L1_error)
+ }
+ __pyx_t_2 = PyFloat_FromDouble((__pyx_t_6 / __pyx_v_sigma)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 248, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_49 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
+ __pyx_t_49 = PyMethod_GET_SELF(__pyx_t_5);
+ if (likely(__pyx_t_49)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
+ __Pyx_INCREF(__pyx_t_49);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_5, function);
+ }
+ }
+ __pyx_t_36 = (__pyx_t_49) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_49, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_49); __pyx_t_49 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ if (unlikely(!__pyx_t_36)) __PYX_ERR(0, 248, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_36);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_36); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 248, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_36); __pyx_t_36 = 0;
+ __pyx_v_weight = __pyx_t_6;
+
+ /* "nms.pyx":247
+ * else:
+ * weight = 1
+ * elif method == 2: # gaussian # <<<<<<<<<<<<<<
+ * weight = np.exp(-(ov * ov)/sigma)
+ * else: # original NMS
+ */
+ break;
+ default:
+
+ /* "nms.pyx":250
+ * weight = np.exp(-(ov * ov)/sigma)
+ * else: # original NMS
+ * if ov > Nt: # <<<<<<<<<<<<<<
+ * weight = 0
+ * else:
+ */
+ __pyx_t_8 = ((__pyx_v_ov > __pyx_v_Nt) != 0);
+ if (__pyx_t_8) {
+
+ /* "nms.pyx":251
+ * else: # original NMS
+ * if ov > Nt:
+ * weight = 0 # <<<<<<<<<<<<<<
+ * else:
+ * weight = 1
+ */
+ __pyx_v_weight = 0.0;
+
+ /* "nms.pyx":250
+ * weight = np.exp(-(ov * ov)/sigma)
+ * else: # original NMS
+ * if ov > Nt: # <<<<<<<<<<<<<<
+ * weight = 0
+ * else:
+ */
+ goto __pyx_L15;
+ }
+
+ /* "nms.pyx":253
+ * weight = 0
+ * else:
+ * weight = 1 # <<<<<<<<<<<<<<
+ *
+ * boxes[pos, 4] = weight*boxes[pos, 4]
+ */
+ /*else*/ {
+ __pyx_v_weight = 1.0;
+ }
+ __pyx_L15:;
+ break;
+ }
+
+ /* "nms.pyx":255
+ * weight = 1
+ *
+ * boxes[pos, 4] = weight*boxes[pos, 4] # <<<<<<<<<<<<<<
+ *
+ * # if box score falls below threshold, discard the box by swapping with last box
+ */
+ __pyx_t_50 = __pyx_v_pos;
+ __pyx_t_51 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_50 < 0) {
+ __pyx_t_50 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_50 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_50 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_51 < 0) {
+ __pyx_t_51 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_51 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_51 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 255, __pyx_L1_error)
+ }
+ __pyx_t_52 = __pyx_v_pos;
+ __pyx_t_53 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_52 < 0) {
+ __pyx_t_52 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_52 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_52 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_53 < 0) {
+ __pyx_t_53 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_53 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_53 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 255, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_52, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_53, __pyx_pybuffernd_boxes.diminfo[1].strides) = (__pyx_v_weight * (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_50, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_51, __pyx_pybuffernd_boxes.diminfo[1].strides)));
+
+ /* "nms.pyx":259
+ * # if box score falls below threshold, discard the box by swapping with last box
+ * # update N
+ * if boxes[pos, 4] < threshold: # <<<<<<<<<<<<<<
+ * boxes[pos,0] = boxes[N-1, 0]
+ * boxes[pos,1] = boxes[N-1, 1]
+ */
+ __pyx_t_54 = __pyx_v_pos;
+ __pyx_t_55 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_54 < 0) {
+ __pyx_t_54 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_54 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_54 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_55 < 0) {
+ __pyx_t_55 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_55 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_55 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 259, __pyx_L1_error)
+ }
+ __pyx_t_8 = (((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_54, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_55, __pyx_pybuffernd_boxes.diminfo[1].strides)) < __pyx_v_threshold) != 0);
+ if (__pyx_t_8) {
+
+ /* "nms.pyx":260
+ * # update N
+ * if boxes[pos, 4] < threshold:
+ * boxes[pos,0] = boxes[N-1, 0] # <<<<<<<<<<<<<<
+ * boxes[pos,1] = boxes[N-1, 1]
+ * boxes[pos,2] = boxes[N-1, 2]
+ */
+ __pyx_t_56 = (__pyx_v_N - 1);
+ __pyx_t_57 = 0;
+ __pyx_t_7 = -1;
+ if (__pyx_t_56 < 0) {
+ __pyx_t_56 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_56 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_56 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_57 < 0) {
+ __pyx_t_57 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_57 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_57 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 260, __pyx_L1_error)
+ }
+ __pyx_t_58 = __pyx_v_pos;
+ __pyx_t_59 = 0;
+ __pyx_t_7 = -1;
+ if (__pyx_t_58 < 0) {
+ __pyx_t_58 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_58 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_58 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_59 < 0) {
+ __pyx_t_59 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_59 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_59 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 260, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_58, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_59, __pyx_pybuffernd_boxes.diminfo[1].strides) = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_56, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_57, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":261
+ * if boxes[pos, 4] < threshold:
+ * boxes[pos,0] = boxes[N-1, 0]
+ * boxes[pos,1] = boxes[N-1, 1] # <<<<<<<<<<<<<<
+ * boxes[pos,2] = boxes[N-1, 2]
+ * boxes[pos,3] = boxes[N-1, 3]
+ */
+ __pyx_t_60 = (__pyx_v_N - 1);
+ __pyx_t_61 = 1;
+ __pyx_t_7 = -1;
+ if (__pyx_t_60 < 0) {
+ __pyx_t_60 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_60 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_60 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_61 < 0) {
+ __pyx_t_61 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_61 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_61 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 261, __pyx_L1_error)
+ }
+ __pyx_t_62 = __pyx_v_pos;
+ __pyx_t_63 = 1;
+ __pyx_t_7 = -1;
+ if (__pyx_t_62 < 0) {
+ __pyx_t_62 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_62 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_62 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_63 < 0) {
+ __pyx_t_63 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_63 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_63 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 261, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_62, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_63, __pyx_pybuffernd_boxes.diminfo[1].strides) = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_60, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_61, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":262
+ * boxes[pos,0] = boxes[N-1, 0]
+ * boxes[pos,1] = boxes[N-1, 1]
+ * boxes[pos,2] = boxes[N-1, 2] # <<<<<<<<<<<<<<
+ * boxes[pos,3] = boxes[N-1, 3]
+ * boxes[pos,4] = boxes[N-1, 4]
+ */
+ __pyx_t_64 = (__pyx_v_N - 1);
+ __pyx_t_65 = 2;
+ __pyx_t_7 = -1;
+ if (__pyx_t_64 < 0) {
+ __pyx_t_64 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_64 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_64 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_65 < 0) {
+ __pyx_t_65 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_65 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_65 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 262, __pyx_L1_error)
+ }
+ __pyx_t_66 = __pyx_v_pos;
+ __pyx_t_67 = 2;
+ __pyx_t_7 = -1;
+ if (__pyx_t_66 < 0) {
+ __pyx_t_66 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_66 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_66 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_67 < 0) {
+ __pyx_t_67 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_67 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_67 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 262, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_66, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_67, __pyx_pybuffernd_boxes.diminfo[1].strides) = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_64, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_65, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":263
+ * boxes[pos,1] = boxes[N-1, 1]
+ * boxes[pos,2] = boxes[N-1, 2]
+ * boxes[pos,3] = boxes[N-1, 3] # <<<<<<<<<<<<<<
+ * boxes[pos,4] = boxes[N-1, 4]
+ * for j in range(5, 39):
+ */
+ __pyx_t_68 = (__pyx_v_N - 1);
+ __pyx_t_69 = 3;
+ __pyx_t_7 = -1;
+ if (__pyx_t_68 < 0) {
+ __pyx_t_68 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_68 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_68 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_69 < 0) {
+ __pyx_t_69 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_69 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_69 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 263, __pyx_L1_error)
+ }
+ __pyx_t_70 = __pyx_v_pos;
+ __pyx_t_71 = 3;
+ __pyx_t_7 = -1;
+ if (__pyx_t_70 < 0) {
+ __pyx_t_70 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_70 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_70 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_71 < 0) {
+ __pyx_t_71 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_71 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_71 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 263, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_70, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_71, __pyx_pybuffernd_boxes.diminfo[1].strides) = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_68, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_69, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":264
+ * boxes[pos,2] = boxes[N-1, 2]
+ * boxes[pos,3] = boxes[N-1, 3]
+ * boxes[pos,4] = boxes[N-1, 4] # <<<<<<<<<<<<<<
+ * for j in range(5, 39):
+ * tmp = boxes[pos, j]
+ */
+ __pyx_t_72 = (__pyx_v_N - 1);
+ __pyx_t_73 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_72 < 0) {
+ __pyx_t_72 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_72 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_72 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_73 < 0) {
+ __pyx_t_73 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_73 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_73 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 264, __pyx_L1_error)
+ }
+ __pyx_t_74 = __pyx_v_pos;
+ __pyx_t_75 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_74 < 0) {
+ __pyx_t_74 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_74 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_74 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_75 < 0) {
+ __pyx_t_75 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_75 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_75 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 264, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_74, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_75, __pyx_pybuffernd_boxes.diminfo[1].strides) = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_72, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_73, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":265
+ * boxes[pos,3] = boxes[N-1, 3]
+ * boxes[pos,4] = boxes[N-1, 4]
+ * for j in range(5, 39): # <<<<<<<<<<<<<<
+ * tmp = boxes[pos, j]
+ * boxes[pos, j] = boxes[N - 1, j]
+ */
+ for (__pyx_t_33 = 5; __pyx_t_33 < 39; __pyx_t_33+=1) {
+ __pyx_v_j = __pyx_t_33;
+
+ /* "nms.pyx":266
+ * boxes[pos,4] = boxes[N-1, 4]
+ * for j in range(5, 39):
+ * tmp = boxes[pos, j] # <<<<<<<<<<<<<<
+ * boxes[pos, j] = boxes[N - 1, j]
+ * boxes[N - 1, j] = tmp
+ */
+ __pyx_t_76 = __pyx_v_pos;
+ __pyx_t_77 = __pyx_v_j;
+ __pyx_t_7 = -1;
+ if (__pyx_t_76 < 0) {
+ __pyx_t_76 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_76 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_76 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_77 < 0) {
+ __pyx_t_77 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_77 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_77 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 266, __pyx_L1_error)
+ }
+ __pyx_v_tmp = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_76, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_77, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":267
+ * for j in range(5, 39):
+ * tmp = boxes[pos, j]
+ * boxes[pos, j] = boxes[N - 1, j] # <<<<<<<<<<<<<<
+ * boxes[N - 1, j] = tmp
+ * N = N - 1
+ */
+ __pyx_t_78 = (__pyx_v_N - 1);
+ __pyx_t_79 = __pyx_v_j;
+ __pyx_t_7 = -1;
+ if (__pyx_t_78 < 0) {
+ __pyx_t_78 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_78 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_78 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_79 < 0) {
+ __pyx_t_79 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_79 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_79 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 267, __pyx_L1_error)
+ }
+ __pyx_t_80 = __pyx_v_pos;
+ __pyx_t_81 = __pyx_v_j;
+ __pyx_t_7 = -1;
+ if (__pyx_t_80 < 0) {
+ __pyx_t_80 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_80 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_80 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_81 < 0) {
+ __pyx_t_81 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_81 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_81 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 267, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_80, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_81, __pyx_pybuffernd_boxes.diminfo[1].strides) = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_78, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_79, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":268
+ * tmp = boxes[pos, j]
+ * boxes[pos, j] = boxes[N - 1, j]
+ * boxes[N - 1, j] = tmp # <<<<<<<<<<<<<<
+ * N = N - 1
+ * pos = pos - 1
+ */
+ __pyx_t_82 = (__pyx_v_N - 1);
+ __pyx_t_83 = __pyx_v_j;
+ __pyx_t_7 = -1;
+ if (__pyx_t_82 < 0) {
+ __pyx_t_82 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_82 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_82 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_83 < 0) {
+ __pyx_t_83 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_83 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_83 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 268, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_82, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_83, __pyx_pybuffernd_boxes.diminfo[1].strides) = __pyx_v_tmp;
+ }
+
+ /* "nms.pyx":269
+ * boxes[pos, j] = boxes[N - 1, j]
+ * boxes[N - 1, j] = tmp
+ * N = N - 1 # <<<<<<<<<<<<<<
+ * pos = pos - 1
+ *
+ */
+ __pyx_v_N = (__pyx_v_N - 1);
+
+ /* "nms.pyx":270
+ * boxes[N - 1, j] = tmp
+ * N = N - 1
+ * pos = pos - 1 # <<<<<<<<<<<<<<
+ *
+ * pos = pos + 1
+ */
+ __pyx_v_pos = (__pyx_v_pos - 1);
+
+ /* "nms.pyx":259
+ * # if box score falls below threshold, discard the box by swapping with last box
+ * # update N
+ * if boxes[pos, 4] < threshold: # <<<<<<<<<<<<<<
+ * boxes[pos,0] = boxes[N-1, 0]
+ * boxes[pos,1] = boxes[N-1, 1]
+ */
+ }
+
+ /* "nms.pyx":238
+ * if iw > 0:
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1)
+ * if ih > 0: # <<<<<<<<<<<<<<
+ * ua = float((tx2 - tx1 + 1) * (ty2 - ty1 + 1) + area - iw * ih)
+ * ov = iw * ih / ua #iou between max box and detection box
+ */
+ }
+
+ /* "nms.pyx":236
+ * area = (x2 - x1 + 1) * (y2 - y1 + 1)
+ * iw = (min(tx2, x2) - max(tx1, x1) + 1)
+ * if iw > 0: # <<<<<<<<<<<<<<
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1)
+ * if ih > 0:
+ */
+ }
+
+ /* "nms.pyx":272
+ * pos = pos - 1
+ *
+ * pos = pos + 1 # <<<<<<<<<<<<<<
+ *
+ * keep = [i for i in range(N)]
+ */
+ __pyx_v_pos = (__pyx_v_pos + 1);
+ }
+
+ /* "nms.pyx":182
+ * cdef float tmp
+ *
+ * for i in range(N): # <<<<<<<<<<<<<<
+ * maxscore = boxes[i, 4]
+ * maxpos = i
+ */
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "nms.pyx":274
+ * pos = pos + 1
+ *
+ * keep = [i for i in range(N)] # <<<<<<<<<<<<<<
+ * return keep
+ *
+ */
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 274, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_36 = __Pyx_PyInt_From_unsigned_int(__pyx_v_N); if (unlikely(!__pyx_t_36)) __PYX_ERR(0, 274, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_36);
+ __pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_36); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 274, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_36); __pyx_t_36 = 0;
+ if (likely(PyList_CheckExact(__pyx_t_5)) || PyTuple_CheckExact(__pyx_t_5)) {
+ __pyx_t_36 = __pyx_t_5; __Pyx_INCREF(__pyx_t_36); __pyx_t_3 = 0;
+ __pyx_t_4 = NULL;
+ } else {
+ __pyx_t_3 = -1; __pyx_t_36 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_36)) __PYX_ERR(0, 274, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_36);
+ __pyx_t_4 = Py_TYPE(__pyx_t_36)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 274, __pyx_L1_error)
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ for (;;) {
+ if (likely(!__pyx_t_4)) {
+ if (likely(PyList_CheckExact(__pyx_t_36))) {
+ if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_36)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_5 = PyList_GET_ITEM(__pyx_t_36, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 274, __pyx_L1_error)
+ #else
+ __pyx_t_5 = PySequence_ITEM(__pyx_t_36, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 274, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ #endif
+ } else {
+ if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_36)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_36, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 274, __pyx_L1_error)
+ #else
+ __pyx_t_5 = PySequence_ITEM(__pyx_t_36, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 274, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ #endif
+ }
+ } else {
+ __pyx_t_5 = __pyx_t_4(__pyx_t_36);
+ if (unlikely(!__pyx_t_5)) {
+ PyObject* exc_type = PyErr_Occurred();
+ if (exc_type) {
+ if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+ else __PYX_ERR(0, 274, __pyx_L1_error)
+ }
+ break;
+ }
+ __Pyx_GOTREF(__pyx_t_5);
+ }
+ __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_5);
+ __pyx_t_5 = 0;
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_v_i))) __PYX_ERR(0, 274, __pyx_L1_error)
+ }
+ __Pyx_DECREF(__pyx_t_36); __pyx_t_36 = 0;
+ __pyx_v_keep = ((PyObject*)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "nms.pyx":275
+ *
+ * keep = [i for i in range(N)]
+ * return keep # <<<<<<<<<<<<<<
+ *
+ * def soft_nms_merge(np.ndarray[float, ndim=2] boxes, float sigma=0.5, float Nt=0.3, float threshold=0.001, unsigned int method=0, float weight_exp=6):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(__pyx_v_keep);
+ __pyx_r = __pyx_v_keep;
+ goto __pyx_L0;
+
+ /* "nms.pyx":172
+ * return keep
+ *
+ * def soft_nms_39(np.ndarray[float, ndim=2] boxes, float sigma=0.5, float Nt=0.3, float threshold=0.001, unsigned int method=0): # <<<<<<<<<<<<<<
+ * cdef unsigned int N = boxes.shape[0]
+ * cdef float iw, ih, box_area
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_36);
+ __Pyx_XDECREF(__pyx_t_49);
+ { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
+ __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer);
+ __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+ __Pyx_AddTraceback("nms.soft_nms_39", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ goto __pyx_L2;
+ __pyx_L0:;
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer);
+ __pyx_L2:;
+ __Pyx_XDECREF(__pyx_v_i);
+ __Pyx_XDECREF(__pyx_v_s);
+ __Pyx_XDECREF(__pyx_v_keep);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "nms.pyx":277
+ * return keep
+ *
+ * def soft_nms_merge(np.ndarray[float, ndim=2] boxes, float sigma=0.5, float Nt=0.3, float threshold=0.001, unsigned int method=0, float weight_exp=6): # <<<<<<<<<<<<<<
+ * cdef unsigned int N = boxes.shape[0]
+ * cdef float iw, ih, box_area
+ */
+
+/* Python wrapper */
+static PyObject *__pyx_pw_3nms_7soft_nms_merge(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
+static PyMethodDef __pyx_mdef_3nms_7soft_nms_merge = {"soft_nms_merge", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3nms_7soft_nms_merge, METH_VARARGS|METH_KEYWORDS, 0};
+static PyObject *__pyx_pw_3nms_7soft_nms_merge(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
+ PyArrayObject *__pyx_v_boxes = 0;
+ float __pyx_v_sigma;
+ float __pyx_v_Nt;
+ float __pyx_v_threshold;
+ unsigned int __pyx_v_method;
+ float __pyx_v_weight_exp;
+ PyObject *__pyx_r = 0;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("soft_nms_merge (wrapper)", 0);
+ {
+ static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_boxes,&__pyx_n_s_sigma,&__pyx_n_s_Nt,&__pyx_n_s_threshold,&__pyx_n_s_method,&__pyx_n_s_weight_exp,0};
+ PyObject* values[6] = {0,0,0,0,0,0};
+ if (unlikely(__pyx_kwds)) {
+ Py_ssize_t kw_args;
+ const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
+ switch (pos_args) {
+ case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ CYTHON_FALLTHROUGH;
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ CYTHON_FALLTHROUGH;
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ CYTHON_FALLTHROUGH;
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ CYTHON_FALLTHROUGH;
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ CYTHON_FALLTHROUGH;
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ CYTHON_FALLTHROUGH;
+ case 0: break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ kw_args = PyDict_Size(__pyx_kwds);
+ switch (pos_args) {
+ case 0:
+ if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_boxes)) != 0)) kw_args--;
+ else goto __pyx_L5_argtuple_error;
+ CYTHON_FALLTHROUGH;
+ case 1:
+ if (kw_args > 0) {
+ PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sigma);
+ if (value) { values[1] = value; kw_args--; }
+ }
+ CYTHON_FALLTHROUGH;
+ case 2:
+ if (kw_args > 0) {
+ PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_Nt);
+ if (value) { values[2] = value; kw_args--; }
+ }
+ CYTHON_FALLTHROUGH;
+ case 3:
+ if (kw_args > 0) {
+ PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_threshold);
+ if (value) { values[3] = value; kw_args--; }
+ }
+ CYTHON_FALLTHROUGH;
+ case 4:
+ if (kw_args > 0) {
+ PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_method);
+ if (value) { values[4] = value; kw_args--; }
+ }
+ CYTHON_FALLTHROUGH;
+ case 5:
+ if (kw_args > 0) {
+ PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_weight_exp);
+ if (value) { values[5] = value; kw_args--; }
+ }
+ }
+ if (unlikely(kw_args > 0)) {
+ if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "soft_nms_merge") < 0)) __PYX_ERR(0, 277, __pyx_L3_error)
+ }
+ } else {
+ switch (PyTuple_GET_SIZE(__pyx_args)) {
+ case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
+ CYTHON_FALLTHROUGH;
+ case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
+ CYTHON_FALLTHROUGH;
+ case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
+ CYTHON_FALLTHROUGH;
+ case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
+ CYTHON_FALLTHROUGH;
+ case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
+ CYTHON_FALLTHROUGH;
+ case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
+ break;
+ default: goto __pyx_L5_argtuple_error;
+ }
+ }
+ __pyx_v_boxes = ((PyArrayObject *)values[0]);
+ if (values[1]) {
+ __pyx_v_sigma = __pyx_PyFloat_AsFloat(values[1]); if (unlikely((__pyx_v_sigma == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 277, __pyx_L3_error)
+ } else {
+ __pyx_v_sigma = ((float)0.5);
+ }
+ if (values[2]) {
+ __pyx_v_Nt = __pyx_PyFloat_AsFloat(values[2]); if (unlikely((__pyx_v_Nt == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 277, __pyx_L3_error)
+ } else {
+ __pyx_v_Nt = ((float)0.3);
+ }
+ if (values[3]) {
+ __pyx_v_threshold = __pyx_PyFloat_AsFloat(values[3]); if (unlikely((__pyx_v_threshold == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 277, __pyx_L3_error)
+ } else {
+ __pyx_v_threshold = ((float)0.001);
+ }
+ if (values[4]) {
+ __pyx_v_method = __Pyx_PyInt_As_unsigned_int(values[4]); if (unlikely((__pyx_v_method == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 277, __pyx_L3_error)
+ } else {
+ __pyx_v_method = ((unsigned int)0);
+ }
+ if (values[5]) {
+ __pyx_v_weight_exp = __pyx_PyFloat_AsFloat(values[5]); if (unlikely((__pyx_v_weight_exp == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 277, __pyx_L3_error)
+ } else {
+ __pyx_v_weight_exp = ((float)6.0);
+ }
+ }
+ goto __pyx_L4_argument_unpacking_done;
+ __pyx_L5_argtuple_error:;
+ __Pyx_RaiseArgtupleInvalid("soft_nms_merge", 0, 1, 6, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 277, __pyx_L3_error)
+ __pyx_L3_error:;
+ __Pyx_AddTraceback("nms.soft_nms_merge", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __Pyx_RefNannyFinishContext();
+ return NULL;
+ __pyx_L4_argument_unpacking_done:;
+ if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_boxes), __pyx_ptype_5numpy_ndarray, 1, "boxes", 0))) __PYX_ERR(0, 277, __pyx_L1_error)
+ __pyx_r = __pyx_pf_3nms_6soft_nms_merge(__pyx_self, __pyx_v_boxes, __pyx_v_sigma, __pyx_v_Nt, __pyx_v_threshold, __pyx_v_method, __pyx_v_weight_exp);
+
+ /* function exit code */
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static PyObject *__pyx_pf_3nms_6soft_nms_merge(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, float __pyx_v_sigma, float __pyx_v_Nt, float __pyx_v_threshold, unsigned int __pyx_v_method, float __pyx_v_weight_exp) {
+ unsigned int __pyx_v_N;
+ float __pyx_v_iw;
+ float __pyx_v_ih;
+ float __pyx_v_ua;
+ int __pyx_v_pos;
+ float __pyx_v_maxscore;
+ int __pyx_v_maxpos;
+ float __pyx_v_x1;
+ float __pyx_v_x2;
+ float __pyx_v_y1;
+ float __pyx_v_y2;
+ float __pyx_v_tx1;
+ float __pyx_v_tx2;
+ float __pyx_v_ty1;
+ float __pyx_v_ty2;
+ float __pyx_v_ts;
+ float __pyx_v_area;
+ float __pyx_v_weight;
+ float __pyx_v_ov;
+ float __pyx_v_mx1;
+ float __pyx_v_mx2;
+ float __pyx_v_my1;
+ float __pyx_v_my2;
+ float __pyx_v_mts;
+ float __pyx_v_mbs;
+ float __pyx_v_mw;
+ PyObject *__pyx_v_i = NULL;
+ CYTHON_UNUSED PyObject *__pyx_v_s = NULL;
+ PyObject *__pyx_v_keep = NULL;
+ __Pyx_LocalBuf_ND __pyx_pybuffernd_boxes;
+ __Pyx_Buffer __pyx_pybuffer_boxes;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ PyObject *__pyx_t_2 = NULL;
+ Py_ssize_t __pyx_t_3;
+ PyObject *(*__pyx_t_4)(PyObject *);
+ PyObject *__pyx_t_5 = NULL;
+ float __pyx_t_6;
+ int __pyx_t_7;
+ int __pyx_t_8;
+ Py_ssize_t __pyx_t_9;
+ Py_ssize_t __pyx_t_10;
+ Py_ssize_t __pyx_t_11;
+ Py_ssize_t __pyx_t_12;
+ Py_ssize_t __pyx_t_13;
+ Py_ssize_t __pyx_t_14;
+ Py_ssize_t __pyx_t_15;
+ Py_ssize_t __pyx_t_16;
+ Py_ssize_t __pyx_t_17;
+ Py_ssize_t __pyx_t_18;
+ Py_ssize_t __pyx_t_19;
+ Py_ssize_t __pyx_t_20;
+ Py_ssize_t __pyx_t_21;
+ Py_ssize_t __pyx_t_22;
+ PyObject *__pyx_t_23 = NULL;
+ Py_ssize_t __pyx_t_24;
+ Py_ssize_t __pyx_t_25;
+ Py_ssize_t __pyx_t_26;
+ Py_ssize_t __pyx_t_27;
+ Py_ssize_t __pyx_t_28;
+ Py_ssize_t __pyx_t_29;
+ Py_ssize_t __pyx_t_30;
+ Py_ssize_t __pyx_t_31;
+ Py_ssize_t __pyx_t_32;
+ Py_ssize_t __pyx_t_33;
+ Py_ssize_t __pyx_t_34;
+ Py_ssize_t __pyx_t_35;
+ Py_ssize_t __pyx_t_36;
+ Py_ssize_t __pyx_t_37;
+ Py_ssize_t __pyx_t_38;
+ Py_ssize_t __pyx_t_39;
+ Py_ssize_t __pyx_t_40;
+ Py_ssize_t __pyx_t_41;
+ Py_ssize_t __pyx_t_42;
+ Py_ssize_t __pyx_t_43;
+ PyObject *__pyx_t_44 = NULL;
+ Py_ssize_t __pyx_t_45;
+ Py_ssize_t __pyx_t_46;
+ Py_ssize_t __pyx_t_47;
+ Py_ssize_t __pyx_t_48;
+ Py_ssize_t __pyx_t_49;
+ Py_ssize_t __pyx_t_50;
+ Py_ssize_t __pyx_t_51;
+ Py_ssize_t __pyx_t_52;
+ Py_ssize_t __pyx_t_53;
+ Py_ssize_t __pyx_t_54;
+ Py_ssize_t __pyx_t_55;
+ Py_ssize_t __pyx_t_56;
+ Py_ssize_t __pyx_t_57;
+ Py_ssize_t __pyx_t_58;
+ Py_ssize_t __pyx_t_59;
+ Py_ssize_t __pyx_t_60;
+ Py_ssize_t __pyx_t_61;
+ Py_ssize_t __pyx_t_62;
+ Py_ssize_t __pyx_t_63;
+ Py_ssize_t __pyx_t_64;
+ Py_ssize_t __pyx_t_65;
+ Py_ssize_t __pyx_t_66;
+ Py_ssize_t __pyx_t_67;
+ Py_ssize_t __pyx_t_68;
+ Py_ssize_t __pyx_t_69;
+ Py_ssize_t __pyx_t_70;
+ Py_ssize_t __pyx_t_71;
+ Py_ssize_t __pyx_t_72;
+ Py_ssize_t __pyx_t_73;
+ Py_ssize_t __pyx_t_74;
+ Py_ssize_t __pyx_t_75;
+ Py_ssize_t __pyx_t_76;
+ Py_ssize_t __pyx_t_77;
+ Py_ssize_t __pyx_t_78;
+ Py_ssize_t __pyx_t_79;
+ Py_ssize_t __pyx_t_80;
+ Py_ssize_t __pyx_t_81;
+ Py_ssize_t __pyx_t_82;
+ Py_ssize_t __pyx_t_83;
+ Py_ssize_t __pyx_t_84;
+ Py_ssize_t __pyx_t_85;
+ Py_ssize_t __pyx_t_86;
+ Py_ssize_t __pyx_t_87;
+ Py_ssize_t __pyx_t_88;
+ Py_ssize_t __pyx_t_89;
+ Py_ssize_t __pyx_t_90;
+ __Pyx_RefNannySetupContext("soft_nms_merge", 0);
+ __pyx_pybuffer_boxes.pybuffer.buf = NULL;
+ __pyx_pybuffer_boxes.refcount = 0;
+ __pyx_pybuffernd_boxes.data = NULL;
+ __pyx_pybuffernd_boxes.rcbuffer = &__pyx_pybuffer_boxes;
+ {
+ __Pyx_BufFmt_StackElem __pyx_stack[1];
+ if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_boxes, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 277, __pyx_L1_error)
+ }
+ __pyx_pybuffernd_boxes.diminfo[0].strides = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_boxes.diminfo[0].shape = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_boxes.diminfo[1].strides = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_boxes.diminfo[1].shape = __pyx_pybuffernd_boxes.rcbuffer->pybuffer.shape[1];
+
+ /* "nms.pyx":278
+ *
+ * def soft_nms_merge(np.ndarray[float, ndim=2] boxes, float sigma=0.5, float Nt=0.3, float threshold=0.001, unsigned int method=0, float weight_exp=6):
+ * cdef unsigned int N = boxes.shape[0] # <<<<<<<<<<<<<<
+ * cdef float iw, ih, box_area
+ * cdef float ua
+ */
+ __pyx_v_N = (__pyx_v_boxes->dimensions[0]);
+
+ /* "nms.pyx":281
+ * cdef float iw, ih, box_area
+ * cdef float ua
+ * cdef int pos = 0 # <<<<<<<<<<<<<<
+ * cdef float maxscore = 0
+ * cdef int maxpos = 0
+ */
+ __pyx_v_pos = 0;
+
+ /* "nms.pyx":282
+ * cdef float ua
+ * cdef int pos = 0
+ * cdef float maxscore = 0 # <<<<<<<<<<<<<<
+ * cdef int maxpos = 0
+ * cdef float x1,x2,y1,y2,tx1,tx2,ty1,ty2,ts,area,weight,ov
+ */
+ __pyx_v_maxscore = 0.0;
+
+ /* "nms.pyx":283
+ * cdef int pos = 0
+ * cdef float maxscore = 0
+ * cdef int maxpos = 0 # <<<<<<<<<<<<<<
+ * cdef float x1,x2,y1,y2,tx1,tx2,ty1,ty2,ts,area,weight,ov
+ * cdef float mx1,mx2,my1,my2,mts,mbs,mw
+ */
+ __pyx_v_maxpos = 0;
+
+ /* "nms.pyx":287
+ * cdef float mx1,mx2,my1,my2,mts,mbs,mw
+ *
+ * for i in range(N): # <<<<<<<<<<<<<<
+ * maxscore = boxes[i, 4]
+ * maxpos = i
+ */
+ __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_N); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 287, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 287, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+ if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) {
+ __pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); __pyx_t_3 = 0;
+ __pyx_t_4 = NULL;
+ } else {
+ __pyx_t_3 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 287, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_4 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 287, __pyx_L1_error)
+ }
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ for (;;) {
+ if (likely(!__pyx_t_4)) {
+ if (likely(PyList_CheckExact(__pyx_t_1))) {
+ if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_1)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_3); __Pyx_INCREF(__pyx_t_2); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 287, __pyx_L1_error)
+ #else
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 287, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ #endif
+ } else {
+ if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_3); __Pyx_INCREF(__pyx_t_2); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 287, __pyx_L1_error)
+ #else
+ __pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 287, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ #endif
+ }
+ } else {
+ __pyx_t_2 = __pyx_t_4(__pyx_t_1);
+ if (unlikely(!__pyx_t_2)) {
+ PyObject* exc_type = PyErr_Occurred();
+ if (exc_type) {
+ if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+ else __PYX_ERR(0, 287, __pyx_L1_error)
+ }
+ break;
+ }
+ __Pyx_GOTREF(__pyx_t_2);
+ }
+ __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_2);
+ __pyx_t_2 = 0;
+
+ /* "nms.pyx":288
+ *
+ * for i in range(N):
+ * maxscore = boxes[i, 4] # <<<<<<<<<<<<<<
+ * maxpos = i
+ *
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 288, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_4);
+ __Pyx_GIVEREF(__pyx_int_4);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_4);
+ __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 288, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 288, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_maxscore = __pyx_t_6;
+
+ /* "nms.pyx":289
+ * for i in range(N):
+ * maxscore = boxes[i, 4]
+ * maxpos = i # <<<<<<<<<<<<<<
+ *
+ * tx1 = boxes[i,0]
+ */
+ __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_v_i); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 289, __pyx_L1_error)
+ __pyx_v_maxpos = __pyx_t_7;
+
+ /* "nms.pyx":291
+ * maxpos = i
+ *
+ * tx1 = boxes[i,0] # <<<<<<<<<<<<<<
+ * ty1 = boxes[i,1]
+ * tx2 = boxes[i,2]
+ */
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 291, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_0);
+ __Pyx_GIVEREF(__pyx_int_0);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_0);
+ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 291, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 291, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_tx1 = __pyx_t_6;
+
+ /* "nms.pyx":292
+ *
+ * tx1 = boxes[i,0]
+ * ty1 = boxes[i,1] # <<<<<<<<<<<<<<
+ * tx2 = boxes[i,2]
+ * ty2 = boxes[i,3]
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 292, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_1);
+ __Pyx_GIVEREF(__pyx_int_1);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_1);
+ __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 292, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 292, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_ty1 = __pyx_t_6;
+
+ /* "nms.pyx":293
+ * tx1 = boxes[i,0]
+ * ty1 = boxes[i,1]
+ * tx2 = boxes[i,2] # <<<<<<<<<<<<<<
+ * ty2 = boxes[i,3]
+ * ts = boxes[i,4]
+ */
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 293, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_2);
+ __Pyx_GIVEREF(__pyx_int_2);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_2);
+ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 293, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 293, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_tx2 = __pyx_t_6;
+
+ /* "nms.pyx":294
+ * ty1 = boxes[i,1]
+ * tx2 = boxes[i,2]
+ * ty2 = boxes[i,3] # <<<<<<<<<<<<<<
+ * ts = boxes[i,4]
+ *
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 294, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_3);
+ __Pyx_GIVEREF(__pyx_int_3);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_3);
+ __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 294, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 294, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_ty2 = __pyx_t_6;
+
+ /* "nms.pyx":295
+ * tx2 = boxes[i,2]
+ * ty2 = boxes[i,3]
+ * ts = boxes[i,4] # <<<<<<<<<<<<<<
+ *
+ * pos = i + 1
+ */
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 295, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_4);
+ __Pyx_GIVEREF(__pyx_int_4);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_4);
+ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 295, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 295, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_ts = __pyx_t_6;
+
+ /* "nms.pyx":297
+ * ts = boxes[i,4]
+ *
+ * pos = i + 1 # <<<<<<<<<<<<<<
+ * # get max box
+ * while pos < N:
+ */
+ __pyx_t_2 = __Pyx_PyInt_AddObjC(__pyx_v_i, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 297, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 297, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_pos = __pyx_t_7;
+
+ /* "nms.pyx":299
+ * pos = i + 1
+ * # get max box
+ * while pos < N: # <<<<<<<<<<<<<<
+ * if maxscore < boxes[pos, 4]:
+ * maxscore = boxes[pos, 4]
+ */
+ while (1) {
+ __pyx_t_8 = ((__pyx_v_pos < __pyx_v_N) != 0);
+ if (!__pyx_t_8) break;
+
+ /* "nms.pyx":300
+ * # get max box
+ * while pos < N:
+ * if maxscore < boxes[pos, 4]: # <<<<<<<<<<<<<<
+ * maxscore = boxes[pos, 4]
+ * maxpos = pos
+ */
+ __pyx_t_9 = __pyx_v_pos;
+ __pyx_t_10 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_9 < 0) {
+ __pyx_t_9 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_9 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_9 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_10 < 0) {
+ __pyx_t_10 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_10 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_10 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 300, __pyx_L1_error)
+ }
+ __pyx_t_8 = ((__pyx_v_maxscore < (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_9, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_10, __pyx_pybuffernd_boxes.diminfo[1].strides))) != 0);
+ if (__pyx_t_8) {
+
+ /* "nms.pyx":301
+ * while pos < N:
+ * if maxscore < boxes[pos, 4]:
+ * maxscore = boxes[pos, 4] # <<<<<<<<<<<<<<
+ * maxpos = pos
+ * pos = pos + 1
+ */
+ __pyx_t_11 = __pyx_v_pos;
+ __pyx_t_12 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_11 < 0) {
+ __pyx_t_11 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_11 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_11 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_12 < 0) {
+ __pyx_t_12 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_12 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_12 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 301, __pyx_L1_error)
+ }
+ __pyx_v_maxscore = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_11, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_12, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":302
+ * if maxscore < boxes[pos, 4]:
+ * maxscore = boxes[pos, 4]
+ * maxpos = pos # <<<<<<<<<<<<<<
+ * pos = pos + 1
+ *
+ */
+ __pyx_v_maxpos = __pyx_v_pos;
+
+ /* "nms.pyx":300
+ * # get max box
+ * while pos < N:
+ * if maxscore < boxes[pos, 4]: # <<<<<<<<<<<<<<
+ * maxscore = boxes[pos, 4]
+ * maxpos = pos
+ */
+ }
+
+ /* "nms.pyx":303
+ * maxscore = boxes[pos, 4]
+ * maxpos = pos
+ * pos = pos + 1 # <<<<<<<<<<<<<<
+ *
+ * # add max box as a detection
+ */
+ __pyx_v_pos = (__pyx_v_pos + 1);
+ }
+
+ /* "nms.pyx":306
+ *
+ * # add max box as a detection
+ * boxes[i,0] = boxes[maxpos,0] # <<<<<<<<<<<<<<
+ * boxes[i,1] = boxes[maxpos,1]
+ * boxes[i,2] = boxes[maxpos,2]
+ */
+ __pyx_t_13 = __pyx_v_maxpos;
+ __pyx_t_14 = 0;
+ __pyx_t_7 = -1;
+ if (__pyx_t_13 < 0) {
+ __pyx_t_13 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_13 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_13 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_14 < 0) {
+ __pyx_t_14 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_14 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_14 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 306, __pyx_L1_error)
+ }
+ __pyx_t_2 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_13, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_14, __pyx_pybuffernd_boxes.diminfo[1].strides))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 306, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 306, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_0);
+ __Pyx_GIVEREF(__pyx_int_0);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_0);
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5, __pyx_t_2) < 0)) __PYX_ERR(0, 306, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "nms.pyx":307
+ * # add max box as a detection
+ * boxes[i,0] = boxes[maxpos,0]
+ * boxes[i,1] = boxes[maxpos,1] # <<<<<<<<<<<<<<
+ * boxes[i,2] = boxes[maxpos,2]
+ * boxes[i,3] = boxes[maxpos,3]
+ */
+ __pyx_t_15 = __pyx_v_maxpos;
+ __pyx_t_16 = 1;
+ __pyx_t_7 = -1;
+ if (__pyx_t_15 < 0) {
+ __pyx_t_15 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_15 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_15 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_16 < 0) {
+ __pyx_t_16 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_16 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_16 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 307, __pyx_L1_error)
+ }
+ __pyx_t_2 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_15, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_16, __pyx_pybuffernd_boxes.diminfo[1].strides))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 307, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 307, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_1);
+ __Pyx_GIVEREF(__pyx_int_1);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_1);
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5, __pyx_t_2) < 0)) __PYX_ERR(0, 307, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "nms.pyx":308
+ * boxes[i,0] = boxes[maxpos,0]
+ * boxes[i,1] = boxes[maxpos,1]
+ * boxes[i,2] = boxes[maxpos,2] # <<<<<<<<<<<<<<
+ * boxes[i,3] = boxes[maxpos,3]
+ * boxes[i,4] = boxes[maxpos,4]
+ */
+ __pyx_t_17 = __pyx_v_maxpos;
+ __pyx_t_18 = 2;
+ __pyx_t_7 = -1;
+ if (__pyx_t_17 < 0) {
+ __pyx_t_17 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_17 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_18 < 0) {
+ __pyx_t_18 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_18 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_18 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 308, __pyx_L1_error)
+ }
+ __pyx_t_2 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_17, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_18, __pyx_pybuffernd_boxes.diminfo[1].strides))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 308, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 308, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_2);
+ __Pyx_GIVEREF(__pyx_int_2);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_2);
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5, __pyx_t_2) < 0)) __PYX_ERR(0, 308, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "nms.pyx":309
+ * boxes[i,1] = boxes[maxpos,1]
+ * boxes[i,2] = boxes[maxpos,2]
+ * boxes[i,3] = boxes[maxpos,3] # <<<<<<<<<<<<<<
+ * boxes[i,4] = boxes[maxpos,4]
+ *
+ */
+ __pyx_t_19 = __pyx_v_maxpos;
+ __pyx_t_20 = 3;
+ __pyx_t_7 = -1;
+ if (__pyx_t_19 < 0) {
+ __pyx_t_19 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_19 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_19 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_20 < 0) {
+ __pyx_t_20 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_20 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_20 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 309, __pyx_L1_error)
+ }
+ __pyx_t_2 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_19, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_20, __pyx_pybuffernd_boxes.diminfo[1].strides))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 309, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 309, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_3);
+ __Pyx_GIVEREF(__pyx_int_3);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_3);
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5, __pyx_t_2) < 0)) __PYX_ERR(0, 309, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "nms.pyx":310
+ * boxes[i,2] = boxes[maxpos,2]
+ * boxes[i,3] = boxes[maxpos,3]
+ * boxes[i,4] = boxes[maxpos,4] # <<<<<<<<<<<<<<
+ *
+ * mx1 = boxes[i, 0] * boxes[i, 5]
+ */
+ __pyx_t_21 = __pyx_v_maxpos;
+ __pyx_t_22 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_21 < 0) {
+ __pyx_t_21 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_21 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_21 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_22 < 0) {
+ __pyx_t_22 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_22 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_22 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 310, __pyx_L1_error)
+ }
+ __pyx_t_2 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_21, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_22, __pyx_pybuffernd_boxes.diminfo[1].strides))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 310, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 310, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_4);
+ __Pyx_GIVEREF(__pyx_int_4);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_4);
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5, __pyx_t_2) < 0)) __PYX_ERR(0, 310, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+
+ /* "nms.pyx":312
+ * boxes[i,4] = boxes[maxpos,4]
+ *
+ * mx1 = boxes[i, 0] * boxes[i, 5] # <<<<<<<<<<<<<<
+ * my1 = boxes[i, 1] * boxes[i, 5]
+ * mx2 = boxes[i, 2] * boxes[i, 6]
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 312, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_0);
+ __Pyx_GIVEREF(__pyx_int_0);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_0);
+ __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 312, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 312, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_5);
+ __Pyx_GIVEREF(__pyx_int_5);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_5);
+ __pyx_t_23 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 312, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_23);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = PyNumber_Multiply(__pyx_t_5, __pyx_t_23); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 312, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 312, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_mx1 = __pyx_t_6;
+
+ /* "nms.pyx":313
+ *
+ * mx1 = boxes[i, 0] * boxes[i, 5]
+ * my1 = boxes[i, 1] * boxes[i, 5] # <<<<<<<<<<<<<<
+ * mx2 = boxes[i, 2] * boxes[i, 6]
+ * my2 = boxes[i, 3] * boxes[i, 6]
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 313, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_1);
+ __Pyx_GIVEREF(__pyx_int_1);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_1);
+ __pyx_t_23 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 313, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_23);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 313, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_5);
+ __Pyx_GIVEREF(__pyx_int_5);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_5);
+ __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 313, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = PyNumber_Multiply(__pyx_t_23, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 313, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 313, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_my1 = __pyx_t_6;
+
+ /* "nms.pyx":314
+ * mx1 = boxes[i, 0] * boxes[i, 5]
+ * my1 = boxes[i, 1] * boxes[i, 5]
+ * mx2 = boxes[i, 2] * boxes[i, 6] # <<<<<<<<<<<<<<
+ * my2 = boxes[i, 3] * boxes[i, 6]
+ * mts = boxes[i, 5]
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 314, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_2);
+ __Pyx_GIVEREF(__pyx_int_2);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_2);
+ __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 314, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 314, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_6);
+ __Pyx_GIVEREF(__pyx_int_6);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_6);
+ __pyx_t_23 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 314, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_23);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = PyNumber_Multiply(__pyx_t_5, __pyx_t_23); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 314, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 314, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_mx2 = __pyx_t_6;
+
+ /* "nms.pyx":315
+ * my1 = boxes[i, 1] * boxes[i, 5]
+ * mx2 = boxes[i, 2] * boxes[i, 6]
+ * my2 = boxes[i, 3] * boxes[i, 6] # <<<<<<<<<<<<<<
+ * mts = boxes[i, 5]
+ * mbs = boxes[i, 6]
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 315, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_3);
+ __Pyx_GIVEREF(__pyx_int_3);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_3);
+ __pyx_t_23 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 315, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_23);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 315, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_6);
+ __Pyx_GIVEREF(__pyx_int_6);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_6);
+ __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 315, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_2 = PyNumber_Multiply(__pyx_t_23, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 315, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 315, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_my2 = __pyx_t_6;
+
+ /* "nms.pyx":316
+ * mx2 = boxes[i, 2] * boxes[i, 6]
+ * my2 = boxes[i, 3] * boxes[i, 6]
+ * mts = boxes[i, 5] # <<<<<<<<<<<<<<
+ * mbs = boxes[i, 6]
+ *
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 316, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_5);
+ __Pyx_GIVEREF(__pyx_int_5);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_5);
+ __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 316, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 316, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_mts = __pyx_t_6;
+
+ /* "nms.pyx":317
+ * my2 = boxes[i, 3] * boxes[i, 6]
+ * mts = boxes[i, 5]
+ * mbs = boxes[i, 6] # <<<<<<<<<<<<<<
+ *
+ * # swap ith box with position of max box
+ */
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 317, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_6);
+ __Pyx_GIVEREF(__pyx_int_6);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_6);
+ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 317, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 317, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_mbs = __pyx_t_6;
+
+ /* "nms.pyx":320
+ *
+ * # swap ith box with position of max box
+ * boxes[maxpos,0] = tx1 # <<<<<<<<<<<<<<
+ * boxes[maxpos,1] = ty1
+ * boxes[maxpos,2] = tx2
+ */
+ __pyx_t_24 = __pyx_v_maxpos;
+ __pyx_t_25 = 0;
+ __pyx_t_7 = -1;
+ if (__pyx_t_24 < 0) {
+ __pyx_t_24 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_24 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_24 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_25 < 0) {
+ __pyx_t_25 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_25 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_25 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 320, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_24, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_25, __pyx_pybuffernd_boxes.diminfo[1].strides) = __pyx_v_tx1;
+
+ /* "nms.pyx":321
+ * # swap ith box with position of max box
+ * boxes[maxpos,0] = tx1
+ * boxes[maxpos,1] = ty1 # <<<<<<<<<<<<<<
+ * boxes[maxpos,2] = tx2
+ * boxes[maxpos,3] = ty2
+ */
+ __pyx_t_26 = __pyx_v_maxpos;
+ __pyx_t_27 = 1;
+ __pyx_t_7 = -1;
+ if (__pyx_t_26 < 0) {
+ __pyx_t_26 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_26 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_26 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_27 < 0) {
+ __pyx_t_27 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_27 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_27 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 321, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_26, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_27, __pyx_pybuffernd_boxes.diminfo[1].strides) = __pyx_v_ty1;
+
+ /* "nms.pyx":322
+ * boxes[maxpos,0] = tx1
+ * boxes[maxpos,1] = ty1
+ * boxes[maxpos,2] = tx2 # <<<<<<<<<<<<<<
+ * boxes[maxpos,3] = ty2
+ * boxes[maxpos,4] = ts
+ */
+ __pyx_t_28 = __pyx_v_maxpos;
+ __pyx_t_29 = 2;
+ __pyx_t_7 = -1;
+ if (__pyx_t_28 < 0) {
+ __pyx_t_28 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_28 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_28 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_29 < 0) {
+ __pyx_t_29 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_29 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_29 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 322, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_28, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_29, __pyx_pybuffernd_boxes.diminfo[1].strides) = __pyx_v_tx2;
+
+ /* "nms.pyx":323
+ * boxes[maxpos,1] = ty1
+ * boxes[maxpos,2] = tx2
+ * boxes[maxpos,3] = ty2 # <<<<<<<<<<<<<<
+ * boxes[maxpos,4] = ts
+ *
+ */
+ __pyx_t_30 = __pyx_v_maxpos;
+ __pyx_t_31 = 3;
+ __pyx_t_7 = -1;
+ if (__pyx_t_30 < 0) {
+ __pyx_t_30 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_30 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_30 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_31 < 0) {
+ __pyx_t_31 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_31 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_31 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 323, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_30, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_31, __pyx_pybuffernd_boxes.diminfo[1].strides) = __pyx_v_ty2;
+
+ /* "nms.pyx":324
+ * boxes[maxpos,2] = tx2
+ * boxes[maxpos,3] = ty2
+ * boxes[maxpos,4] = ts # <<<<<<<<<<<<<<
+ *
+ * tx1 = boxes[i,0]
+ */
+ __pyx_t_32 = __pyx_v_maxpos;
+ __pyx_t_33 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_32 < 0) {
+ __pyx_t_32 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_32 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_32 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_33 < 0) {
+ __pyx_t_33 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_33 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_33 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 324, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_32, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_33, __pyx_pybuffernd_boxes.diminfo[1].strides) = __pyx_v_ts;
+
+ /* "nms.pyx":326
+ * boxes[maxpos,4] = ts
+ *
+ * tx1 = boxes[i,0] # <<<<<<<<<<<<<<
+ * ty1 = boxes[i,1]
+ * tx2 = boxes[i,2]
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 326, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_0);
+ __Pyx_GIVEREF(__pyx_int_0);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_0);
+ __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 326, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 326, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_tx1 = __pyx_t_6;
+
+ /* "nms.pyx":327
+ *
+ * tx1 = boxes[i,0]
+ * ty1 = boxes[i,1] # <<<<<<<<<<<<<<
+ * tx2 = boxes[i,2]
+ * ty2 = boxes[i,3]
+ */
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 327, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_1);
+ __Pyx_GIVEREF(__pyx_int_1);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_1);
+ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 327, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 327, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_ty1 = __pyx_t_6;
+
+ /* "nms.pyx":328
+ * tx1 = boxes[i,0]
+ * ty1 = boxes[i,1]
+ * tx2 = boxes[i,2] # <<<<<<<<<<<<<<
+ * ty2 = boxes[i,3]
+ * ts = boxes[i,4]
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 328, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_2);
+ __Pyx_GIVEREF(__pyx_int_2);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_2);
+ __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 328, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 328, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_tx2 = __pyx_t_6;
+
+ /* "nms.pyx":329
+ * ty1 = boxes[i,1]
+ * tx2 = boxes[i,2]
+ * ty2 = boxes[i,3] # <<<<<<<<<<<<<<
+ * ts = boxes[i,4]
+ *
+ */
+ __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 329, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_3);
+ __Pyx_GIVEREF(__pyx_int_3);
+ PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_3);
+ __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 329, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_2); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 329, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_v_ty2 = __pyx_t_6;
+
+ /* "nms.pyx":330
+ * tx2 = boxes[i,2]
+ * ty2 = boxes[i,3]
+ * ts = boxes[i,4] # <<<<<<<<<<<<<<
+ *
+ * pos = i + 1
+ */
+ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 330, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_4);
+ __Pyx_GIVEREF(__pyx_int_4);
+ PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_int_4);
+ __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_boxes), __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 330, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 330, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_ts = __pyx_t_6;
+
+ /* "nms.pyx":332
+ * ts = boxes[i,4]
+ *
+ * pos = i + 1 # <<<<<<<<<<<<<<
+ * # NMS iterations, note that N changes if detection boxes fall below threshold
+ * while pos < N:
+ */
+ __pyx_t_5 = __Pyx_PyInt_AddObjC(__pyx_v_i, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 332, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 332, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_pos = __pyx_t_7;
+
+ /* "nms.pyx":334
+ * pos = i + 1
+ * # NMS iterations, note that N changes if detection boxes fall below threshold
+ * while pos < N: # <<<<<<<<<<<<<<
+ * x1 = boxes[pos, 0]
+ * y1 = boxes[pos, 1]
+ */
+ while (1) {
+ __pyx_t_8 = ((__pyx_v_pos < __pyx_v_N) != 0);
+ if (!__pyx_t_8) break;
+
+ /* "nms.pyx":335
+ * # NMS iterations, note that N changes if detection boxes fall below threshold
+ * while pos < N:
+ * x1 = boxes[pos, 0] # <<<<<<<<<<<<<<
+ * y1 = boxes[pos, 1]
+ * x2 = boxes[pos, 2]
+ */
+ __pyx_t_34 = __pyx_v_pos;
+ __pyx_t_35 = 0;
+ __pyx_t_7 = -1;
+ if (__pyx_t_34 < 0) {
+ __pyx_t_34 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_34 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_34 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_35 < 0) {
+ __pyx_t_35 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_35 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_35 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 335, __pyx_L1_error)
+ }
+ __pyx_v_x1 = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_34, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_35, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":336
+ * while pos < N:
+ * x1 = boxes[pos, 0]
+ * y1 = boxes[pos, 1] # <<<<<<<<<<<<<<
+ * x2 = boxes[pos, 2]
+ * y2 = boxes[pos, 3]
+ */
+ __pyx_t_36 = __pyx_v_pos;
+ __pyx_t_37 = 1;
+ __pyx_t_7 = -1;
+ if (__pyx_t_36 < 0) {
+ __pyx_t_36 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_36 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_36 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_37 < 0) {
+ __pyx_t_37 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_37 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_37 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 336, __pyx_L1_error)
+ }
+ __pyx_v_y1 = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_36, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_37, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":337
+ * x1 = boxes[pos, 0]
+ * y1 = boxes[pos, 1]
+ * x2 = boxes[pos, 2] # <<<<<<<<<<<<<<
+ * y2 = boxes[pos, 3]
+ * s = boxes[pos, 4]
+ */
+ __pyx_t_38 = __pyx_v_pos;
+ __pyx_t_39 = 2;
+ __pyx_t_7 = -1;
+ if (__pyx_t_38 < 0) {
+ __pyx_t_38 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_38 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_38 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_39 < 0) {
+ __pyx_t_39 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_39 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_39 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 337, __pyx_L1_error)
+ }
+ __pyx_v_x2 = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_38, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_39, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":338
+ * y1 = boxes[pos, 1]
+ * x2 = boxes[pos, 2]
+ * y2 = boxes[pos, 3] # <<<<<<<<<<<<<<
+ * s = boxes[pos, 4]
+ *
+ */
+ __pyx_t_40 = __pyx_v_pos;
+ __pyx_t_41 = 3;
+ __pyx_t_7 = -1;
+ if (__pyx_t_40 < 0) {
+ __pyx_t_40 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_40 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_40 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_41 < 0) {
+ __pyx_t_41 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_41 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_41 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 338, __pyx_L1_error)
+ }
+ __pyx_v_y2 = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_40, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_41, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":339
+ * x2 = boxes[pos, 2]
+ * y2 = boxes[pos, 3]
+ * s = boxes[pos, 4] # <<<<<<<<<<<<<<
+ *
+ * area = (x2 - x1 + 1) * (y2 - y1 + 1)
+ */
+ __pyx_t_42 = __pyx_v_pos;
+ __pyx_t_43 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_42 < 0) {
+ __pyx_t_42 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_42 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_42 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_43 < 0) {
+ __pyx_t_43 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_43 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_43 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 339, __pyx_L1_error)
+ }
+ __pyx_t_5 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_42, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_43, __pyx_pybuffernd_boxes.diminfo[1].strides))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 339, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_XDECREF_SET(__pyx_v_s, __pyx_t_5);
+ __pyx_t_5 = 0;
+
+ /* "nms.pyx":341
+ * s = boxes[pos, 4]
+ *
+ * area = (x2 - x1 + 1) * (y2 - y1 + 1) # <<<<<<<<<<<<<<
+ * iw = (min(tx2, x2) - max(tx1, x1) + 1)
+ * if iw > 0:
+ */
+ __pyx_v_area = (((__pyx_v_x2 - __pyx_v_x1) + 1.0) * ((__pyx_v_y2 - __pyx_v_y1) + 1.0));
+
+ /* "nms.pyx":342
+ *
+ * area = (x2 - x1 + 1) * (y2 - y1 + 1)
+ * iw = (min(tx2, x2) - max(tx1, x1) + 1) # <<<<<<<<<<<<<<
+ * if iw > 0:
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1)
+ */
+ __pyx_v_iw = ((__pyx_f_3nms_min(__pyx_v_tx2, __pyx_v_x2) - __pyx_f_3nms_max(__pyx_v_tx1, __pyx_v_x1)) + 1.0);
+
+ /* "nms.pyx":343
+ * area = (x2 - x1 + 1) * (y2 - y1 + 1)
+ * iw = (min(tx2, x2) - max(tx1, x1) + 1)
+ * if iw > 0: # <<<<<<<<<<<<<<
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1)
+ * if ih > 0:
+ */
+ __pyx_t_8 = ((__pyx_v_iw > 0.0) != 0);
+ if (__pyx_t_8) {
+
+ /* "nms.pyx":344
+ * iw = (min(tx2, x2) - max(tx1, x1) + 1)
+ * if iw > 0:
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1) # <<<<<<<<<<<<<<
+ * if ih > 0:
+ * ua = float((tx2 - tx1 + 1) * (ty2 - ty1 + 1) + area - iw * ih)
+ */
+ __pyx_v_ih = ((__pyx_f_3nms_min(__pyx_v_ty2, __pyx_v_y2) - __pyx_f_3nms_max(__pyx_v_ty1, __pyx_v_y1)) + 1.0);
+
+ /* "nms.pyx":345
+ * if iw > 0:
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1)
+ * if ih > 0: # <<<<<<<<<<<<<<
+ * ua = float((tx2 - tx1 + 1) * (ty2 - ty1 + 1) + area - iw * ih)
+ * ov = iw * ih / ua #iou between max box and detection box
+ */
+ __pyx_t_8 = ((__pyx_v_ih > 0.0) != 0);
+ if (__pyx_t_8) {
+
+ /* "nms.pyx":346
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1)
+ * if ih > 0:
+ * ua = float((tx2 - tx1 + 1) * (ty2 - ty1 + 1) + area - iw * ih) # <<<<<<<<<<<<<<
+ * ov = iw * ih / ua #iou between max box and detection box
+ *
+ */
+ __pyx_v_ua = ((double)(((((__pyx_v_tx2 - __pyx_v_tx1) + 1.0) * ((__pyx_v_ty2 - __pyx_v_ty1) + 1.0)) + __pyx_v_area) - (__pyx_v_iw * __pyx_v_ih)));
+
+ /* "nms.pyx":347
+ * if ih > 0:
+ * ua = float((tx2 - tx1 + 1) * (ty2 - ty1 + 1) + area - iw * ih)
+ * ov = iw * ih / ua #iou between max box and detection box # <<<<<<<<<<<<<<
+ *
+ * if method == 1: # linear
+ */
+ __pyx_t_6 = (__pyx_v_iw * __pyx_v_ih);
+ if (unlikely(__pyx_v_ua == 0)) {
+ PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+ __PYX_ERR(0, 347, __pyx_L1_error)
+ }
+ __pyx_v_ov = (__pyx_t_6 / __pyx_v_ua);
+
+ /* "nms.pyx":349
+ * ov = iw * ih / ua #iou between max box and detection box
+ *
+ * if method == 1: # linear # <<<<<<<<<<<<<<
+ * if ov > Nt:
+ * weight = 1 - ov
+ */
+ switch (__pyx_v_method) {
+ case 1:
+
+ /* "nms.pyx":350
+ *
+ * if method == 1: # linear
+ * if ov > Nt: # <<<<<<<<<<<<<<
+ * weight = 1 - ov
+ * else:
+ */
+ __pyx_t_8 = ((__pyx_v_ov > __pyx_v_Nt) != 0);
+ if (__pyx_t_8) {
+
+ /* "nms.pyx":351
+ * if method == 1: # linear
+ * if ov > Nt:
+ * weight = 1 - ov # <<<<<<<<<<<<<<
+ * else:
+ * weight = 1
+ */
+ __pyx_v_weight = (1.0 - __pyx_v_ov);
+
+ /* "nms.pyx":350
+ *
+ * if method == 1: # linear
+ * if ov > Nt: # <<<<<<<<<<<<<<
+ * weight = 1 - ov
+ * else:
+ */
+ goto __pyx_L12;
+ }
+
+ /* "nms.pyx":353
+ * weight = 1 - ov
+ * else:
+ * weight = 1 # <<<<<<<<<<<<<<
+ * elif method == 2: # gaussian
+ * weight = np.exp(-(ov * ov)/sigma)
+ */
+ /*else*/ {
+ __pyx_v_weight = 1.0;
+ }
+ __pyx_L12:;
+
+ /* "nms.pyx":349
+ * ov = iw * ih / ua #iou between max box and detection box
+ *
+ * if method == 1: # linear # <<<<<<<<<<<<<<
+ * if ov > Nt:
+ * weight = 1 - ov
+ */
+ break;
+ case 2:
+
+ /* "nms.pyx":355
+ * weight = 1
+ * elif method == 2: # gaussian
+ * weight = np.exp(-(ov * ov)/sigma) # <<<<<<<<<<<<<<
+ * else: # original NMS
+ * if ov > Nt:
+ */
+ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 355, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_exp); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 355, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_23);
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ __pyx_t_6 = (-(__pyx_v_ov * __pyx_v_ov));
+ if (unlikely(__pyx_v_sigma == 0)) {
+ PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+ __PYX_ERR(0, 355, __pyx_L1_error)
+ }
+ __pyx_t_2 = PyFloat_FromDouble((__pyx_t_6 / __pyx_v_sigma)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 355, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_2);
+ __pyx_t_44 = NULL;
+ if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_23))) {
+ __pyx_t_44 = PyMethod_GET_SELF(__pyx_t_23);
+ if (likely(__pyx_t_44)) {
+ PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_23);
+ __Pyx_INCREF(__pyx_t_44);
+ __Pyx_INCREF(function);
+ __Pyx_DECREF_SET(__pyx_t_23, function);
+ }
+ }
+ __pyx_t_5 = (__pyx_t_44) ? __Pyx_PyObject_Call2Args(__pyx_t_23, __pyx_t_44, __pyx_t_2) : __Pyx_PyObject_CallOneArg(__pyx_t_23, __pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_44); __pyx_t_44 = 0;
+ __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
+ if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 355, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
+ __pyx_t_6 = __pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_6 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 355, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_weight = __pyx_t_6;
+
+ /* "nms.pyx":354
+ * else:
+ * weight = 1
+ * elif method == 2: # gaussian # <<<<<<<<<<<<<<
+ * weight = np.exp(-(ov * ov)/sigma)
+ * else: # original NMS
+ */
+ break;
+ default:
+
+ /* "nms.pyx":357
+ * weight = np.exp(-(ov * ov)/sigma)
+ * else: # original NMS
+ * if ov > Nt: # <<<<<<<<<<<<<<
+ * weight = 0
+ * else:
+ */
+ __pyx_t_8 = ((__pyx_v_ov > __pyx_v_Nt) != 0);
+ if (__pyx_t_8) {
+
+ /* "nms.pyx":358
+ * else: # original NMS
+ * if ov > Nt:
+ * weight = 0 # <<<<<<<<<<<<<<
+ * else:
+ * weight = 1
+ */
+ __pyx_v_weight = 0.0;
+
+ /* "nms.pyx":357
+ * weight = np.exp(-(ov * ov)/sigma)
+ * else: # original NMS
+ * if ov > Nt: # <<<<<<<<<<<<<<
+ * weight = 0
+ * else:
+ */
+ goto __pyx_L13;
+ }
+
+ /* "nms.pyx":360
+ * weight = 0
+ * else:
+ * weight = 1 # <<<<<<<<<<<<<<
+ *
+ * mw = (1 - weight) ** weight_exp
+ */
+ /*else*/ {
+ __pyx_v_weight = 1.0;
+ }
+ __pyx_L13:;
+ break;
+ }
+
+ /* "nms.pyx":362
+ * weight = 1
+ *
+ * mw = (1 - weight) ** weight_exp # <<<<<<<<<<<<<<
+ * mx1 = mx1 + boxes[pos, 0] * boxes[pos, 5] * mw
+ * my1 = my1 + boxes[pos, 1] * boxes[pos, 5] * mw
+ */
+ __pyx_v_mw = powf((1.0 - __pyx_v_weight), __pyx_v_weight_exp);
+
+ /* "nms.pyx":363
+ *
+ * mw = (1 - weight) ** weight_exp
+ * mx1 = mx1 + boxes[pos, 0] * boxes[pos, 5] * mw # <<<<<<<<<<<<<<
+ * my1 = my1 + boxes[pos, 1] * boxes[pos, 5] * mw
+ * mx2 = mx2 + boxes[pos, 2] * boxes[pos, 6] * mw
+ */
+ __pyx_t_45 = __pyx_v_pos;
+ __pyx_t_46 = 0;
+ __pyx_t_7 = -1;
+ if (__pyx_t_45 < 0) {
+ __pyx_t_45 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_45 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_45 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_46 < 0) {
+ __pyx_t_46 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_46 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_46 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 363, __pyx_L1_error)
+ }
+ __pyx_t_47 = __pyx_v_pos;
+ __pyx_t_48 = 5;
+ __pyx_t_7 = -1;
+ if (__pyx_t_47 < 0) {
+ __pyx_t_47 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_47 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_47 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_48 < 0) {
+ __pyx_t_48 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_48 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_48 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 363, __pyx_L1_error)
+ }
+ __pyx_v_mx1 = (__pyx_v_mx1 + (((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_45, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_46, __pyx_pybuffernd_boxes.diminfo[1].strides)) * (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_47, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_48, __pyx_pybuffernd_boxes.diminfo[1].strides))) * __pyx_v_mw));
+
+ /* "nms.pyx":364
+ * mw = (1 - weight) ** weight_exp
+ * mx1 = mx1 + boxes[pos, 0] * boxes[pos, 5] * mw
+ * my1 = my1 + boxes[pos, 1] * boxes[pos, 5] * mw # <<<<<<<<<<<<<<
+ * mx2 = mx2 + boxes[pos, 2] * boxes[pos, 6] * mw
+ * my2 = my2 + boxes[pos, 3] * boxes[pos, 6] * mw
+ */
+ __pyx_t_49 = __pyx_v_pos;
+ __pyx_t_50 = 1;
+ __pyx_t_7 = -1;
+ if (__pyx_t_49 < 0) {
+ __pyx_t_49 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_49 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_49 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_50 < 0) {
+ __pyx_t_50 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_50 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_50 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 364, __pyx_L1_error)
+ }
+ __pyx_t_51 = __pyx_v_pos;
+ __pyx_t_52 = 5;
+ __pyx_t_7 = -1;
+ if (__pyx_t_51 < 0) {
+ __pyx_t_51 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_51 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_51 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_52 < 0) {
+ __pyx_t_52 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_52 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_52 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 364, __pyx_L1_error)
+ }
+ __pyx_v_my1 = (__pyx_v_my1 + (((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_49, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_50, __pyx_pybuffernd_boxes.diminfo[1].strides)) * (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_51, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_52, __pyx_pybuffernd_boxes.diminfo[1].strides))) * __pyx_v_mw));
+
+ /* "nms.pyx":365
+ * mx1 = mx1 + boxes[pos, 0] * boxes[pos, 5] * mw
+ * my1 = my1 + boxes[pos, 1] * boxes[pos, 5] * mw
+ * mx2 = mx2 + boxes[pos, 2] * boxes[pos, 6] * mw # <<<<<<<<<<<<<<
+ * my2 = my2 + boxes[pos, 3] * boxes[pos, 6] * mw
+ * mts = mts + boxes[pos, 5] * mw
+ */
+ __pyx_t_53 = __pyx_v_pos;
+ __pyx_t_54 = 2;
+ __pyx_t_7 = -1;
+ if (__pyx_t_53 < 0) {
+ __pyx_t_53 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_53 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_53 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_54 < 0) {
+ __pyx_t_54 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_54 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_54 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 365, __pyx_L1_error)
+ }
+ __pyx_t_55 = __pyx_v_pos;
+ __pyx_t_56 = 6;
+ __pyx_t_7 = -1;
+ if (__pyx_t_55 < 0) {
+ __pyx_t_55 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_55 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_55 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_56 < 0) {
+ __pyx_t_56 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_56 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_56 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 365, __pyx_L1_error)
+ }
+ __pyx_v_mx2 = (__pyx_v_mx2 + (((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_53, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_54, __pyx_pybuffernd_boxes.diminfo[1].strides)) * (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_55, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_56, __pyx_pybuffernd_boxes.diminfo[1].strides))) * __pyx_v_mw));
+
+ /* "nms.pyx":366
+ * my1 = my1 + boxes[pos, 1] * boxes[pos, 5] * mw
+ * mx2 = mx2 + boxes[pos, 2] * boxes[pos, 6] * mw
+ * my2 = my2 + boxes[pos, 3] * boxes[pos, 6] * mw # <<<<<<<<<<<<<<
+ * mts = mts + boxes[pos, 5] * mw
+ * mbs = mbs + boxes[pos, 6] * mw
+ */
+ __pyx_t_57 = __pyx_v_pos;
+ __pyx_t_58 = 3;
+ __pyx_t_7 = -1;
+ if (__pyx_t_57 < 0) {
+ __pyx_t_57 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_57 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_57 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_58 < 0) {
+ __pyx_t_58 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_58 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_58 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 366, __pyx_L1_error)
+ }
+ __pyx_t_59 = __pyx_v_pos;
+ __pyx_t_60 = 6;
+ __pyx_t_7 = -1;
+ if (__pyx_t_59 < 0) {
+ __pyx_t_59 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_59 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_59 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_60 < 0) {
+ __pyx_t_60 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_60 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_60 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 366, __pyx_L1_error)
+ }
+ __pyx_v_my2 = (__pyx_v_my2 + (((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_57, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_58, __pyx_pybuffernd_boxes.diminfo[1].strides)) * (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_59, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_60, __pyx_pybuffernd_boxes.diminfo[1].strides))) * __pyx_v_mw));
+
+ /* "nms.pyx":367
+ * mx2 = mx2 + boxes[pos, 2] * boxes[pos, 6] * mw
+ * my2 = my2 + boxes[pos, 3] * boxes[pos, 6] * mw
+ * mts = mts + boxes[pos, 5] * mw # <<<<<<<<<<<<<<
+ * mbs = mbs + boxes[pos, 6] * mw
+ *
+ */
+ __pyx_t_61 = __pyx_v_pos;
+ __pyx_t_62 = 5;
+ __pyx_t_7 = -1;
+ if (__pyx_t_61 < 0) {
+ __pyx_t_61 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_61 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_61 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_62 < 0) {
+ __pyx_t_62 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_62 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_62 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 367, __pyx_L1_error)
+ }
+ __pyx_v_mts = (__pyx_v_mts + ((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_61, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_62, __pyx_pybuffernd_boxes.diminfo[1].strides)) * __pyx_v_mw));
+
+ /* "nms.pyx":368
+ * my2 = my2 + boxes[pos, 3] * boxes[pos, 6] * mw
+ * mts = mts + boxes[pos, 5] * mw
+ * mbs = mbs + boxes[pos, 6] * mw # <<<<<<<<<<<<<<
+ *
+ * boxes[pos, 4] = weight*boxes[pos, 4]
+ */
+ __pyx_t_63 = __pyx_v_pos;
+ __pyx_t_64 = 6;
+ __pyx_t_7 = -1;
+ if (__pyx_t_63 < 0) {
+ __pyx_t_63 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_63 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_63 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_64 < 0) {
+ __pyx_t_64 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_64 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_64 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 368, __pyx_L1_error)
+ }
+ __pyx_v_mbs = (__pyx_v_mbs + ((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_63, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_64, __pyx_pybuffernd_boxes.diminfo[1].strides)) * __pyx_v_mw));
+
+ /* "nms.pyx":370
+ * mbs = mbs + boxes[pos, 6] * mw
+ *
+ * boxes[pos, 4] = weight*boxes[pos, 4] # <<<<<<<<<<<<<<
+ *
+ * # if box score falls below threshold, discard the box by swapping with last box
+ */
+ __pyx_t_65 = __pyx_v_pos;
+ __pyx_t_66 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_65 < 0) {
+ __pyx_t_65 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_65 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_65 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_66 < 0) {
+ __pyx_t_66 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_66 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_66 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 370, __pyx_L1_error)
+ }
+ __pyx_t_67 = __pyx_v_pos;
+ __pyx_t_68 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_67 < 0) {
+ __pyx_t_67 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_67 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_67 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_68 < 0) {
+ __pyx_t_68 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_68 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_68 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 370, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_67, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_68, __pyx_pybuffernd_boxes.diminfo[1].strides) = (__pyx_v_weight * (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_65, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_66, __pyx_pybuffernd_boxes.diminfo[1].strides)));
+
+ /* "nms.pyx":374
+ * # if box score falls below threshold, discard the box by swapping with last box
+ * # update N
+ * if boxes[pos, 4] < threshold: # <<<<<<<<<<<<<<
+ * boxes[pos,0] = boxes[N-1, 0]
+ * boxes[pos,1] = boxes[N-1, 1]
+ */
+ __pyx_t_69 = __pyx_v_pos;
+ __pyx_t_70 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_69 < 0) {
+ __pyx_t_69 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_69 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_69 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_70 < 0) {
+ __pyx_t_70 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_70 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_70 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 374, __pyx_L1_error)
+ }
+ __pyx_t_8 = (((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_69, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_70, __pyx_pybuffernd_boxes.diminfo[1].strides)) < __pyx_v_threshold) != 0);
+ if (__pyx_t_8) {
+
+ /* "nms.pyx":375
+ * # update N
+ * if boxes[pos, 4] < threshold:
+ * boxes[pos,0] = boxes[N-1, 0] # <<<<<<<<<<<<<<
+ * boxes[pos,1] = boxes[N-1, 1]
+ * boxes[pos,2] = boxes[N-1, 2]
+ */
+ __pyx_t_71 = (__pyx_v_N - 1);
+ __pyx_t_72 = 0;
+ __pyx_t_7 = -1;
+ if (__pyx_t_71 < 0) {
+ __pyx_t_71 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_71 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_71 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_72 < 0) {
+ __pyx_t_72 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_72 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_72 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 375, __pyx_L1_error)
+ }
+ __pyx_t_73 = __pyx_v_pos;
+ __pyx_t_74 = 0;
+ __pyx_t_7 = -1;
+ if (__pyx_t_73 < 0) {
+ __pyx_t_73 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_73 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_73 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_74 < 0) {
+ __pyx_t_74 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_74 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_74 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 375, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_73, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_74, __pyx_pybuffernd_boxes.diminfo[1].strides) = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_71, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_72, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":376
+ * if boxes[pos, 4] < threshold:
+ * boxes[pos,0] = boxes[N-1, 0]
+ * boxes[pos,1] = boxes[N-1, 1] # <<<<<<<<<<<<<<
+ * boxes[pos,2] = boxes[N-1, 2]
+ * boxes[pos,3] = boxes[N-1, 3]
+ */
+ __pyx_t_75 = (__pyx_v_N - 1);
+ __pyx_t_76 = 1;
+ __pyx_t_7 = -1;
+ if (__pyx_t_75 < 0) {
+ __pyx_t_75 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_75 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_75 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_76 < 0) {
+ __pyx_t_76 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_76 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_76 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 376, __pyx_L1_error)
+ }
+ __pyx_t_77 = __pyx_v_pos;
+ __pyx_t_78 = 1;
+ __pyx_t_7 = -1;
+ if (__pyx_t_77 < 0) {
+ __pyx_t_77 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_77 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_77 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_78 < 0) {
+ __pyx_t_78 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_78 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_78 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 376, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_77, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_78, __pyx_pybuffernd_boxes.diminfo[1].strides) = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_75, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_76, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":377
+ * boxes[pos,0] = boxes[N-1, 0]
+ * boxes[pos,1] = boxes[N-1, 1]
+ * boxes[pos,2] = boxes[N-1, 2] # <<<<<<<<<<<<<<
+ * boxes[pos,3] = boxes[N-1, 3]
+ * boxes[pos,4] = boxes[N-1, 4]
+ */
+ __pyx_t_79 = (__pyx_v_N - 1);
+ __pyx_t_80 = 2;
+ __pyx_t_7 = -1;
+ if (__pyx_t_79 < 0) {
+ __pyx_t_79 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_79 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_79 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_80 < 0) {
+ __pyx_t_80 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_80 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_80 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 377, __pyx_L1_error)
+ }
+ __pyx_t_81 = __pyx_v_pos;
+ __pyx_t_82 = 2;
+ __pyx_t_7 = -1;
+ if (__pyx_t_81 < 0) {
+ __pyx_t_81 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_81 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_81 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_82 < 0) {
+ __pyx_t_82 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_82 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_82 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 377, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_81, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_82, __pyx_pybuffernd_boxes.diminfo[1].strides) = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_79, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_80, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":378
+ * boxes[pos,1] = boxes[N-1, 1]
+ * boxes[pos,2] = boxes[N-1, 2]
+ * boxes[pos,3] = boxes[N-1, 3] # <<<<<<<<<<<<<<
+ * boxes[pos,4] = boxes[N-1, 4]
+ * N = N - 1
+ */
+ __pyx_t_83 = (__pyx_v_N - 1);
+ __pyx_t_84 = 3;
+ __pyx_t_7 = -1;
+ if (__pyx_t_83 < 0) {
+ __pyx_t_83 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_83 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_83 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_84 < 0) {
+ __pyx_t_84 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_84 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_84 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 378, __pyx_L1_error)
+ }
+ __pyx_t_85 = __pyx_v_pos;
+ __pyx_t_86 = 3;
+ __pyx_t_7 = -1;
+ if (__pyx_t_85 < 0) {
+ __pyx_t_85 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_85 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_85 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_86 < 0) {
+ __pyx_t_86 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_86 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_86 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 378, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_85, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_86, __pyx_pybuffernd_boxes.diminfo[1].strides) = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_83, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_84, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":379
+ * boxes[pos,2] = boxes[N-1, 2]
+ * boxes[pos,3] = boxes[N-1, 3]
+ * boxes[pos,4] = boxes[N-1, 4] # <<<<<<<<<<<<<<
+ * N = N - 1
+ * pos = pos - 1
+ */
+ __pyx_t_87 = (__pyx_v_N - 1);
+ __pyx_t_88 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_87 < 0) {
+ __pyx_t_87 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_87 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_87 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_88 < 0) {
+ __pyx_t_88 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_88 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_88 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 379, __pyx_L1_error)
+ }
+ __pyx_t_89 = __pyx_v_pos;
+ __pyx_t_90 = 4;
+ __pyx_t_7 = -1;
+ if (__pyx_t_89 < 0) {
+ __pyx_t_89 += __pyx_pybuffernd_boxes.diminfo[0].shape;
+ if (unlikely(__pyx_t_89 < 0)) __pyx_t_7 = 0;
+ } else if (unlikely(__pyx_t_89 >= __pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_7 = 0;
+ if (__pyx_t_90 < 0) {
+ __pyx_t_90 += __pyx_pybuffernd_boxes.diminfo[1].shape;
+ if (unlikely(__pyx_t_90 < 0)) __pyx_t_7 = 1;
+ } else if (unlikely(__pyx_t_90 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_7 = 1;
+ if (unlikely(__pyx_t_7 != -1)) {
+ __Pyx_RaiseBufferIndexError(__pyx_t_7);
+ __PYX_ERR(0, 379, __pyx_L1_error)
+ }
+ *__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_89, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_90, __pyx_pybuffernd_boxes.diminfo[1].strides) = (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_87, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_88, __pyx_pybuffernd_boxes.diminfo[1].strides));
+
+ /* "nms.pyx":380
+ * boxes[pos,3] = boxes[N-1, 3]
+ * boxes[pos,4] = boxes[N-1, 4]
+ * N = N - 1 # <<<<<<<<<<<<<<
+ * pos = pos - 1
+ *
+ */
+ __pyx_v_N = (__pyx_v_N - 1);
+
+ /* "nms.pyx":381
+ * boxes[pos,4] = boxes[N-1, 4]
+ * N = N - 1
+ * pos = pos - 1 # <<<<<<<<<<<<<<
+ *
+ * pos = pos + 1
+ */
+ __pyx_v_pos = (__pyx_v_pos - 1);
+
+ /* "nms.pyx":374
+ * # if box score falls below threshold, discard the box by swapping with last box
+ * # update N
+ * if boxes[pos, 4] < threshold: # <<<<<<<<<<<<<<
+ * boxes[pos,0] = boxes[N-1, 0]
+ * boxes[pos,1] = boxes[N-1, 1]
+ */
+ }
+
+ /* "nms.pyx":345
+ * if iw > 0:
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1)
+ * if ih > 0: # <<<<<<<<<<<<<<
+ * ua = float((tx2 - tx1 + 1) * (ty2 - ty1 + 1) + area - iw * ih)
+ * ov = iw * ih / ua #iou between max box and detection box
+ */
+ }
+
+ /* "nms.pyx":343
+ * area = (x2 - x1 + 1) * (y2 - y1 + 1)
+ * iw = (min(tx2, x2) - max(tx1, x1) + 1)
+ * if iw > 0: # <<<<<<<<<<<<<<
+ * ih = (min(ty2, y2) - max(ty1, y1) + 1)
+ * if ih > 0:
+ */
+ }
+
+ /* "nms.pyx":383
+ * pos = pos - 1
+ *
+ * pos = pos + 1 # <<<<<<<<<<<<<<
+ *
+ * boxes[i, 0] = mx1 / mts
+ */
+ __pyx_v_pos = (__pyx_v_pos + 1);
+ }
+
+ /* "nms.pyx":385
+ * pos = pos + 1
+ *
+ * boxes[i, 0] = mx1 / mts # <<<<<<<<<<<<<<
+ * boxes[i, 1] = my1 / mts
+ * boxes[i, 2] = mx2 / mbs
+ */
+ if (unlikely(__pyx_v_mts == 0)) {
+ PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+ __PYX_ERR(0, 385, __pyx_L1_error)
+ }
+ __pyx_t_5 = PyFloat_FromDouble((__pyx_v_mx1 / __pyx_v_mts)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 385, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_23 = PyTuple_New(2); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 385, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_23);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_23, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_0);
+ __Pyx_GIVEREF(__pyx_int_0);
+ PyTuple_SET_ITEM(__pyx_t_23, 1, __pyx_int_0);
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_boxes), __pyx_t_23, __pyx_t_5) < 0)) __PYX_ERR(0, 385, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+ /* "nms.pyx":386
+ *
+ * boxes[i, 0] = mx1 / mts
+ * boxes[i, 1] = my1 / mts # <<<<<<<<<<<<<<
+ * boxes[i, 2] = mx2 / mbs
+ * boxes[i, 3] = my2 / mbs
+ */
+ if (unlikely(__pyx_v_mts == 0)) {
+ PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+ __PYX_ERR(0, 386, __pyx_L1_error)
+ }
+ __pyx_t_5 = PyFloat_FromDouble((__pyx_v_my1 / __pyx_v_mts)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 386, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_23 = PyTuple_New(2); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 386, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_23);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_23, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_1);
+ __Pyx_GIVEREF(__pyx_int_1);
+ PyTuple_SET_ITEM(__pyx_t_23, 1, __pyx_int_1);
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_boxes), __pyx_t_23, __pyx_t_5) < 0)) __PYX_ERR(0, 386, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+ /* "nms.pyx":387
+ * boxes[i, 0] = mx1 / mts
+ * boxes[i, 1] = my1 / mts
+ * boxes[i, 2] = mx2 / mbs # <<<<<<<<<<<<<<
+ * boxes[i, 3] = my2 / mbs
+ *
+ */
+ if (unlikely(__pyx_v_mbs == 0)) {
+ PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+ __PYX_ERR(0, 387, __pyx_L1_error)
+ }
+ __pyx_t_5 = PyFloat_FromDouble((__pyx_v_mx2 / __pyx_v_mbs)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 387, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_23 = PyTuple_New(2); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 387, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_23);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_23, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_2);
+ __Pyx_GIVEREF(__pyx_int_2);
+ PyTuple_SET_ITEM(__pyx_t_23, 1, __pyx_int_2);
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_boxes), __pyx_t_23, __pyx_t_5) < 0)) __PYX_ERR(0, 387, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+ /* "nms.pyx":388
+ * boxes[i, 1] = my1 / mts
+ * boxes[i, 2] = mx2 / mbs
+ * boxes[i, 3] = my2 / mbs # <<<<<<<<<<<<<<
+ *
+ * keep = [i for i in range(N)]
+ */
+ if (unlikely(__pyx_v_mbs == 0)) {
+ PyErr_SetString(PyExc_ZeroDivisionError, "float division");
+ __PYX_ERR(0, 388, __pyx_L1_error)
+ }
+ __pyx_t_5 = PyFloat_FromDouble((__pyx_v_my2 / __pyx_v_mbs)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 388, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_23 = PyTuple_New(2); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 388, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_23);
+ __Pyx_INCREF(__pyx_v_i);
+ __Pyx_GIVEREF(__pyx_v_i);
+ PyTuple_SET_ITEM(__pyx_t_23, 0, __pyx_v_i);
+ __Pyx_INCREF(__pyx_int_3);
+ __Pyx_GIVEREF(__pyx_int_3);
+ PyTuple_SET_ITEM(__pyx_t_23, 1, __pyx_int_3);
+ if (unlikely(PyObject_SetItem(((PyObject *)__pyx_v_boxes), __pyx_t_23, __pyx_t_5) < 0)) __PYX_ERR(0, 388, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+
+ /* "nms.pyx":287
+ * cdef float mx1,mx2,my1,my2,mts,mbs,mw
+ *
+ * for i in range(N): # <<<<<<<<<<<<<<
+ * maxscore = boxes[i, 4]
+ * maxpos = i
+ */
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "nms.pyx":390
+ * boxes[i, 3] = my2 / mbs
+ *
+ * keep = [i for i in range(N)] # <<<<<<<<<<<<<<
+ * return keep
+ */
+ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 390, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_t_5 = __Pyx_PyInt_From_unsigned_int(__pyx_v_N); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 390, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_23 = __Pyx_PyObject_CallOneArg(__pyx_builtin_range, __pyx_t_5); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 390, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_23);
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ if (likely(PyList_CheckExact(__pyx_t_23)) || PyTuple_CheckExact(__pyx_t_23)) {
+ __pyx_t_5 = __pyx_t_23; __Pyx_INCREF(__pyx_t_5); __pyx_t_3 = 0;
+ __pyx_t_4 = NULL;
+ } else {
+ __pyx_t_3 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_t_23); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 390, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_5);
+ __pyx_t_4 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 390, __pyx_L1_error)
+ }
+ __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0;
+ for (;;) {
+ if (likely(!__pyx_t_4)) {
+ if (likely(PyList_CheckExact(__pyx_t_5))) {
+ if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_5)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_23 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_3); __Pyx_INCREF(__pyx_t_23); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 390, __pyx_L1_error)
+ #else
+ __pyx_t_23 = PySequence_ITEM(__pyx_t_5, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 390, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_23);
+ #endif
+ } else {
+ if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_5)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_23 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_3); __Pyx_INCREF(__pyx_t_23); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(0, 390, __pyx_L1_error)
+ #else
+ __pyx_t_23 = PySequence_ITEM(__pyx_t_5, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 390, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_23);
+ #endif
+ }
+ } else {
+ __pyx_t_23 = __pyx_t_4(__pyx_t_5);
+ if (unlikely(!__pyx_t_23)) {
+ PyObject* exc_type = PyErr_Occurred();
+ if (exc_type) {
+ if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
+ else __PYX_ERR(0, 390, __pyx_L1_error)
+ }
+ break;
+ }
+ __Pyx_GOTREF(__pyx_t_23);
+ }
+ __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_23);
+ __pyx_t_23 = 0;
+ if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_v_i))) __PYX_ERR(0, 390, __pyx_L1_error)
+ }
+ __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
+ __pyx_v_keep = ((PyObject*)__pyx_t_1);
+ __pyx_t_1 = 0;
+
+ /* "nms.pyx":391
+ *
+ * keep = [i for i in range(N)]
+ * return keep # <<<<<<<<<<<<<<
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(__pyx_v_keep);
+ __pyx_r = __pyx_v_keep;
+ goto __pyx_L0;
+
+ /* "nms.pyx":277
+ * return keep
+ *
+ * def soft_nms_merge(np.ndarray[float, ndim=2] boxes, float sigma=0.5, float Nt=0.3, float threshold=0.001, unsigned int method=0, float weight_exp=6): # <<<<<<<<<<<<<<
+ * cdef unsigned int N = boxes.shape[0]
+ * cdef float iw, ih, box_area
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_2);
+ __Pyx_XDECREF(__pyx_t_5);
+ __Pyx_XDECREF(__pyx_t_23);
+ __Pyx_XDECREF(__pyx_t_44);
+ { PyObject *__pyx_type, *__pyx_value, *__pyx_tb;
+ __Pyx_PyThreadState_declare
+ __Pyx_PyThreadState_assign
+ __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb);
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer);
+ __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);}
+ __Pyx_AddTraceback("nms.soft_nms_merge", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ goto __pyx_L2;
+ __pyx_L0:;
+ __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer);
+ __pyx_L2:;
+ __Pyx_XDECREF(__pyx_v_i);
+ __Pyx_XDECREF(__pyx_v_s);
+ __Pyx_XDECREF(__pyx_v_keep);
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":258
+ * # experimental exception made for __getbuffer__ and __releasebuffer__
+ * # -- the details of this may change.
+ * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<<
+ * # This implementation of getbuffer is geared towards Cython
+ * # requirements, and does not yet fulfill the PEP.
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/
+static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0);
+ __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) {
+ int __pyx_v_i;
+ int __pyx_v_ndim;
+ int __pyx_v_endian_detector;
+ int __pyx_v_little_endian;
+ int __pyx_v_t;
+ char *__pyx_v_f;
+ PyArray_Descr *__pyx_v_descr = 0;
+ int __pyx_v_offset;
+ int __pyx_r;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ int __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ int __pyx_t_4;
+ int __pyx_t_5;
+ int __pyx_t_6;
+ PyArray_Descr *__pyx_t_7;
+ PyObject *__pyx_t_8 = NULL;
+ char *__pyx_t_9;
+ if (__pyx_v_info == NULL) {
+ PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete");
+ return -1;
+ }
+ __Pyx_RefNannySetupContext("__getbuffer__", 0);
+ __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None);
+ __Pyx_GIVEREF(__pyx_v_info->obj);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":265
+ *
+ * cdef int i, ndim
+ * cdef int endian_detector = 1 # <<<<<<<<<<<<<<
+ * cdef bint little_endian = ((&endian_detector)[0] != 0)
+ *
+ */
+ __pyx_v_endian_detector = 1;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":266
+ * cdef int i, ndim
+ * cdef int endian_detector = 1
+ * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<<
+ *
+ * ndim = PyArray_NDIM(self)
+ */
+ __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":268
+ * cdef bint little_endian = ((&endian_detector)[0] != 0)
+ *
+ * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<<
+ *
+ * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ */
+ __pyx_v_ndim = PyArray_NDIM(__pyx_v_self);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":270
+ * ndim = PyArray_NDIM(self)
+ *
+ * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<<
+ * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)):
+ * raise ValueError(u"ndarray is not C contiguous")
+ */
+ __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0);
+ if (__pyx_t_2) {
+ } else {
+ __pyx_t_1 = __pyx_t_2;
+ goto __pyx_L4_bool_binop_done;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":271
+ *
+ * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)): # <<<<<<<<<<<<<<
+ * raise ValueError(u"ndarray is not C contiguous")
+ *
+ */
+ __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_C_CONTIGUOUS) != 0)) != 0);
+ __pyx_t_1 = __pyx_t_2;
+ __pyx_L4_bool_binop_done:;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":270
+ * ndim = PyArray_NDIM(self)
+ *
+ * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<<
+ * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)):
+ * raise ValueError(u"ndarray is not C contiguous")
+ */
+ if (unlikely(__pyx_t_1)) {
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":272
+ * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS)
+ * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)):
+ * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<<
+ *
+ * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ */
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 272, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(1, 272, __pyx_L1_error)
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":270
+ * ndim = PyArray_NDIM(self)
+ *
+ * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<<
+ * and not PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)):
+ * raise ValueError(u"ndarray is not C contiguous")
+ */
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":274
+ * raise ValueError(u"ndarray is not C contiguous")
+ *
+ * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<<
+ * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)):
+ * raise ValueError(u"ndarray is not Fortran contiguous")
+ */
+ __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0);
+ if (__pyx_t_2) {
+ } else {
+ __pyx_t_1 = __pyx_t_2;
+ goto __pyx_L7_bool_binop_done;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":275
+ *
+ * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)): # <<<<<<<<<<<<<<
+ * raise ValueError(u"ndarray is not Fortran contiguous")
+ *
+ */
+ __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_ARRAY_F_CONTIGUOUS) != 0)) != 0);
+ __pyx_t_1 = __pyx_t_2;
+ __pyx_L7_bool_binop_done:;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":274
+ * raise ValueError(u"ndarray is not C contiguous")
+ *
+ * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<<
+ * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)):
+ * raise ValueError(u"ndarray is not Fortran contiguous")
+ */
+ if (unlikely(__pyx_t_1)) {
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":276
+ * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS)
+ * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)):
+ * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<<
+ *
+ * info.buf = PyArray_DATA(self)
+ */
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 276, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(1, 276, __pyx_L1_error)
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":274
+ * raise ValueError(u"ndarray is not C contiguous")
+ *
+ * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<<
+ * and not PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)):
+ * raise ValueError(u"ndarray is not Fortran contiguous")
+ */
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":278
+ * raise ValueError(u"ndarray is not Fortran contiguous")
+ *
+ * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<<
+ * info.ndim = ndim
+ * if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ */
+ __pyx_v_info->buf = PyArray_DATA(__pyx_v_self);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":279
+ *
+ * info.buf = PyArray_DATA(self)
+ * info.ndim = ndim # <<<<<<<<<<<<<<
+ * if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ * # Allocate new buffer for strides and shape info.
+ */
+ __pyx_v_info->ndim = __pyx_v_ndim;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":280
+ * info.buf = PyArray_DATA(self)
+ * info.ndim = ndim
+ * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<<
+ * # Allocate new buffer for strides and shape info.
+ * # This is allocated as one block, strides first.
+ */
+ __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
+ if (__pyx_t_1) {
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":283
+ * # Allocate new buffer for strides and shape info.
+ * # This is allocated as one block, strides first.
+ * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim) # <<<<<<<<<<<<<<
+ * info.shape = info.strides + ndim
+ * for i in range(ndim):
+ */
+ __pyx_v_info->strides = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * 2) * ((size_t)__pyx_v_ndim))));
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":284
+ * # This is allocated as one block, strides first.
+ * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim)
+ * info.shape = info.strides + ndim # <<<<<<<<<<<<<<
+ * for i in range(ndim):
+ * info.strides[i] = PyArray_STRIDES(self)[i]
+ */
+ __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":285
+ * info.strides = PyObject_Malloc(sizeof(Py_ssize_t) * 2 * ndim)
+ * info.shape = info.strides + ndim
+ * for i in range(ndim): # <<<<<<<<<<<<<<
+ * info.strides[i] = PyArray_STRIDES(self)[i]
+ * info.shape[i] = PyArray_DIMS(self)[i]
+ */
+ __pyx_t_4 = __pyx_v_ndim;
+ __pyx_t_5 = __pyx_t_4;
+ for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) {
+ __pyx_v_i = __pyx_t_6;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":286
+ * info.shape = info.strides + ndim
+ * for i in range(ndim):
+ * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<<
+ * info.shape[i] = PyArray_DIMS(self)[i]
+ * else:
+ */
+ (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":287
+ * for i in range(ndim):
+ * info.strides[i] = PyArray_STRIDES(self)[i]
+ * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<<
+ * else:
+ * info.strides = PyArray_STRIDES(self)
+ */
+ (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]);
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":280
+ * info.buf = PyArray_DATA(self)
+ * info.ndim = ndim
+ * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<<
+ * # Allocate new buffer for strides and shape info.
+ * # This is allocated as one block, strides first.
+ */
+ goto __pyx_L9;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":289
+ * info.shape[i] = PyArray_DIMS(self)[i]
+ * else:
+ * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<<
+ * info.shape = PyArray_DIMS(self)
+ * info.suboffsets = NULL
+ */
+ /*else*/ {
+ __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self));
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":290
+ * else:
+ * info.strides = PyArray_STRIDES(self)
+ * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<<
+ * info.suboffsets = NULL
+ * info.itemsize = PyArray_ITEMSIZE(self)
+ */
+ __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self));
+ }
+ __pyx_L9:;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":291
+ * info.strides = PyArray_STRIDES(self)
+ * info.shape = PyArray_DIMS(self)
+ * info.suboffsets = NULL # <<<<<<<<<<<<<<
+ * info.itemsize = PyArray_ITEMSIZE(self)
+ * info.readonly = not PyArray_ISWRITEABLE(self)
+ */
+ __pyx_v_info->suboffsets = NULL;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":292
+ * info.shape = PyArray_DIMS(self)
+ * info.suboffsets = NULL
+ * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<<
+ * info.readonly = not PyArray_ISWRITEABLE(self)
+ *
+ */
+ __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":293
+ * info.suboffsets = NULL
+ * info.itemsize = PyArray_ITEMSIZE(self)
+ * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<<
+ *
+ * cdef int t
+ */
+ __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0));
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":296
+ *
+ * cdef int t
+ * cdef char* f = NULL # <<<<<<<<<<<<<<
+ * cdef dtype descr = PyArray_DESCR(self)
+ * cdef int offset
+ */
+ __pyx_v_f = NULL;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":297
+ * cdef int t
+ * cdef char* f = NULL
+ * cdef dtype descr = PyArray_DESCR(self) # <<<<<<<<<<<<<<
+ * cdef int offset
+ *
+ */
+ __pyx_t_7 = PyArray_DESCR(__pyx_v_self);
+ __pyx_t_3 = ((PyObject *)__pyx_t_7);
+ __Pyx_INCREF(__pyx_t_3);
+ __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3);
+ __pyx_t_3 = 0;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":300
+ * cdef int offset
+ *
+ * info.obj = self # <<<<<<<<<<<<<<
+ *
+ * if not PyDataType_HASFIELDS(descr):
+ */
+ __Pyx_INCREF(((PyObject *)__pyx_v_self));
+ __Pyx_GIVEREF(((PyObject *)__pyx_v_self));
+ __Pyx_GOTREF(__pyx_v_info->obj);
+ __Pyx_DECREF(__pyx_v_info->obj);
+ __pyx_v_info->obj = ((PyObject *)__pyx_v_self);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":302
+ * info.obj = self
+ *
+ * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<<
+ * t = descr.type_num
+ * if ((descr.byteorder == c'>' and little_endian) or
+ */
+ __pyx_t_1 = ((!(PyDataType_HASFIELDS(__pyx_v_descr) != 0)) != 0);
+ if (__pyx_t_1) {
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":303
+ *
+ * if not PyDataType_HASFIELDS(descr):
+ * t = descr.type_num # <<<<<<<<<<<<<<
+ * if ((descr.byteorder == c'>' and little_endian) or
+ * (descr.byteorder == c'<' and not little_endian)):
+ */
+ __pyx_t_4 = __pyx_v_descr->type_num;
+ __pyx_v_t = __pyx_t_4;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":304
+ * if not PyDataType_HASFIELDS(descr):
+ * t = descr.type_num
+ * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<<
+ * (descr.byteorder == c'<' and not little_endian)):
+ * raise ValueError(u"Non-native byte order not supported")
+ */
+ __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0);
+ if (!__pyx_t_2) {
+ goto __pyx_L15_next_or;
+ } else {
+ }
+ __pyx_t_2 = (__pyx_v_little_endian != 0);
+ if (!__pyx_t_2) {
+ } else {
+ __pyx_t_1 = __pyx_t_2;
+ goto __pyx_L14_bool_binop_done;
+ }
+ __pyx_L15_next_or:;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":305
+ * t = descr.type_num
+ * if ((descr.byteorder == c'>' and little_endian) or
+ * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<<
+ * raise ValueError(u"Non-native byte order not supported")
+ * if t == NPY_BYTE: f = "b"
+ */
+ __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0);
+ if (__pyx_t_2) {
+ } else {
+ __pyx_t_1 = __pyx_t_2;
+ goto __pyx_L14_bool_binop_done;
+ }
+ __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0);
+ __pyx_t_1 = __pyx_t_2;
+ __pyx_L14_bool_binop_done:;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":304
+ * if not PyDataType_HASFIELDS(descr):
+ * t = descr.type_num
+ * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<<
+ * (descr.byteorder == c'<' and not little_endian)):
+ * raise ValueError(u"Non-native byte order not supported")
+ */
+ if (unlikely(__pyx_t_1)) {
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":306
+ * if ((descr.byteorder == c'>' and little_endian) or
+ * (descr.byteorder == c'<' and not little_endian)):
+ * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<<
+ * if t == NPY_BYTE: f = "b"
+ * elif t == NPY_UBYTE: f = "B"
+ */
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 306, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(1, 306, __pyx_L1_error)
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":304
+ * if not PyDataType_HASFIELDS(descr):
+ * t = descr.type_num
+ * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<<
+ * (descr.byteorder == c'<' and not little_endian)):
+ * raise ValueError(u"Non-native byte order not supported")
+ */
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":307
+ * (descr.byteorder == c'<' and not little_endian)):
+ * raise ValueError(u"Non-native byte order not supported")
+ * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<<
+ * elif t == NPY_UBYTE: f = "B"
+ * elif t == NPY_SHORT: f = "h"
+ */
+ switch (__pyx_v_t) {
+ case NPY_BYTE:
+ __pyx_v_f = ((char *)"b");
+ break;
+ case NPY_UBYTE:
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":308
+ * raise ValueError(u"Non-native byte order not supported")
+ * if t == NPY_BYTE: f = "b"
+ * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<<
+ * elif t == NPY_SHORT: f = "h"
+ * elif t == NPY_USHORT: f = "H"
+ */
+ __pyx_v_f = ((char *)"B");
+ break;
+ case NPY_SHORT:
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":309
+ * if t == NPY_BYTE: f = "b"
+ * elif t == NPY_UBYTE: f = "B"
+ * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<<
+ * elif t == NPY_USHORT: f = "H"
+ * elif t == NPY_INT: f = "i"
+ */
+ __pyx_v_f = ((char *)"h");
+ break;
+ case NPY_USHORT:
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":310
+ * elif t == NPY_UBYTE: f = "B"
+ * elif t == NPY_SHORT: f = "h"
+ * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<<
+ * elif t == NPY_INT: f = "i"
+ * elif t == NPY_UINT: f = "I"
+ */
+ __pyx_v_f = ((char *)"H");
+ break;
+ case NPY_INT:
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":311
+ * elif t == NPY_SHORT: f = "h"
+ * elif t == NPY_USHORT: f = "H"
+ * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<<
+ * elif t == NPY_UINT: f = "I"
+ * elif t == NPY_LONG: f = "l"
+ */
+ __pyx_v_f = ((char *)"i");
+ break;
+ case NPY_UINT:
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":312
+ * elif t == NPY_USHORT: f = "H"
+ * elif t == NPY_INT: f = "i"
+ * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<<
+ * elif t == NPY_LONG: f = "l"
+ * elif t == NPY_ULONG: f = "L"
+ */
+ __pyx_v_f = ((char *)"I");
+ break;
+ case NPY_LONG:
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":313
+ * elif t == NPY_INT: f = "i"
+ * elif t == NPY_UINT: f = "I"
+ * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<<
+ * elif t == NPY_ULONG: f = "L"
+ * elif t == NPY_LONGLONG: f = "q"
+ */
+ __pyx_v_f = ((char *)"l");
+ break;
+ case NPY_ULONG:
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":314
+ * elif t == NPY_UINT: f = "I"
+ * elif t == NPY_LONG: f = "l"
+ * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<<
+ * elif t == NPY_LONGLONG: f = "q"
+ * elif t == NPY_ULONGLONG: f = "Q"
+ */
+ __pyx_v_f = ((char *)"L");
+ break;
+ case NPY_LONGLONG:
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":315
+ * elif t == NPY_LONG: f = "l"
+ * elif t == NPY_ULONG: f = "L"
+ * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<<
+ * elif t == NPY_ULONGLONG: f = "Q"
+ * elif t == NPY_FLOAT: f = "f"
+ */
+ __pyx_v_f = ((char *)"q");
+ break;
+ case NPY_ULONGLONG:
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":316
+ * elif t == NPY_ULONG: f = "L"
+ * elif t == NPY_LONGLONG: f = "q"
+ * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<<
+ * elif t == NPY_FLOAT: f = "f"
+ * elif t == NPY_DOUBLE: f = "d"
+ */
+ __pyx_v_f = ((char *)"Q");
+ break;
+ case NPY_FLOAT:
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":317
+ * elif t == NPY_LONGLONG: f = "q"
+ * elif t == NPY_ULONGLONG: f = "Q"
+ * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<<
+ * elif t == NPY_DOUBLE: f = "d"
+ * elif t == NPY_LONGDOUBLE: f = "g"
+ */
+ __pyx_v_f = ((char *)"f");
+ break;
+ case NPY_DOUBLE:
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":318
+ * elif t == NPY_ULONGLONG: f = "Q"
+ * elif t == NPY_FLOAT: f = "f"
+ * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<<
+ * elif t == NPY_LONGDOUBLE: f = "g"
+ * elif t == NPY_CFLOAT: f = "Zf"
+ */
+ __pyx_v_f = ((char *)"d");
+ break;
+ case NPY_LONGDOUBLE:
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":319
+ * elif t == NPY_FLOAT: f = "f"
+ * elif t == NPY_DOUBLE: f = "d"
+ * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<<
+ * elif t == NPY_CFLOAT: f = "Zf"
+ * elif t == NPY_CDOUBLE: f = "Zd"
+ */
+ __pyx_v_f = ((char *)"g");
+ break;
+ case NPY_CFLOAT:
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":320
+ * elif t == NPY_DOUBLE: f = "d"
+ * elif t == NPY_LONGDOUBLE: f = "g"
+ * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<<
+ * elif t == NPY_CDOUBLE: f = "Zd"
+ * elif t == NPY_CLONGDOUBLE: f = "Zg"
+ */
+ __pyx_v_f = ((char *)"Zf");
+ break;
+ case NPY_CDOUBLE:
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":321
+ * elif t == NPY_LONGDOUBLE: f = "g"
+ * elif t == NPY_CFLOAT: f = "Zf"
+ * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<<
+ * elif t == NPY_CLONGDOUBLE: f = "Zg"
+ * elif t == NPY_OBJECT: f = "O"
+ */
+ __pyx_v_f = ((char *)"Zd");
+ break;
+ case NPY_CLONGDOUBLE:
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":322
+ * elif t == NPY_CFLOAT: f = "Zf"
+ * elif t == NPY_CDOUBLE: f = "Zd"
+ * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<<
+ * elif t == NPY_OBJECT: f = "O"
+ * else:
+ */
+ __pyx_v_f = ((char *)"Zg");
+ break;
+ case NPY_OBJECT:
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":323
+ * elif t == NPY_CDOUBLE: f = "Zd"
+ * elif t == NPY_CLONGDOUBLE: f = "Zg"
+ * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<<
+ * else:
+ * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ */
+ __pyx_v_f = ((char *)"O");
+ break;
+ default:
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":325
+ * elif t == NPY_OBJECT: f = "O"
+ * else:
+ * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<<
+ * info.format = f
+ * return
+ */
+ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_8 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 325, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_8);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 325, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(1, 325, __pyx_L1_error)
+ break;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":326
+ * else:
+ * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ * info.format = f # <<<<<<<<<<<<<<
+ * return
+ * else:
+ */
+ __pyx_v_info->format = __pyx_v_f;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":327
+ * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ * info.format = f
+ * return # <<<<<<<<<<<<<<
+ * else:
+ * info.format = PyObject_Malloc(_buffer_format_string_len)
+ */
+ __pyx_r = 0;
+ goto __pyx_L0;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":302
+ * info.obj = self
+ *
+ * if not PyDataType_HASFIELDS(descr): # <<<<<<<<<<<<<<
+ * t = descr.type_num
+ * if ((descr.byteorder == c'>' and little_endian) or
+ */
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":329
+ * return
+ * else:
+ * info.format = PyObject_Malloc(_buffer_format_string_len) # <<<<<<<<<<<<<<
+ * info.format[0] = c'^' # Native data types, manual alignment
+ * offset = 0
+ */
+ /*else*/ {
+ __pyx_v_info->format = ((char *)PyObject_Malloc(0xFF));
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":330
+ * else:
+ * info.format = PyObject_Malloc(_buffer_format_string_len)
+ * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<<
+ * offset = 0
+ * f = _util_dtypestring(descr, info.format + 1,
+ */
+ (__pyx_v_info->format[0]) = '^';
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":331
+ * info.format = PyObject_Malloc(_buffer_format_string_len)
+ * info.format[0] = c'^' # Native data types, manual alignment
+ * offset = 0 # <<<<<<<<<<<<<<
+ * f = _util_dtypestring(descr, info.format + 1,
+ * info.format + _buffer_format_string_len,
+ */
+ __pyx_v_offset = 0;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":332
+ * info.format[0] = c'^' # Native data types, manual alignment
+ * offset = 0
+ * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<<
+ * info.format + _buffer_format_string_len,
+ * &offset)
+ */
+ __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 332, __pyx_L1_error)
+ __pyx_v_f = __pyx_t_9;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":335
+ * info.format + _buffer_format_string_len,
+ * &offset)
+ * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<<
+ *
+ * def __releasebuffer__(ndarray self, Py_buffer* info):
+ */
+ (__pyx_v_f[0]) = '\x00';
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":258
+ * # experimental exception made for __getbuffer__ and __releasebuffer__
+ * # -- the details of this may change.
+ * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<<
+ * # This implementation of getbuffer is geared towards Cython
+ * # requirements, and does not yet fulfill the PEP.
+ */
+
+ /* function exit code */
+ __pyx_r = 0;
+ goto __pyx_L0;
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_8);
+ __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = -1;
+ if (__pyx_v_info->obj != NULL) {
+ __Pyx_GOTREF(__pyx_v_info->obj);
+ __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
+ }
+ goto __pyx_L2;
+ __pyx_L0:;
+ if (__pyx_v_info->obj == Py_None) {
+ __Pyx_GOTREF(__pyx_v_info->obj);
+ __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0;
+ }
+ __pyx_L2:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_descr);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":337
+ * f[0] = c'\0' # Terminate format string
+ *
+ * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<<
+ * if PyArray_HASFIELDS(self):
+ * PyObject_Free(info.format)
+ */
+
+/* Python wrapper */
+static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/
+static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) {
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0);
+ __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info));
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+}
+
+static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) {
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ __Pyx_RefNannySetupContext("__releasebuffer__", 0);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":338
+ *
+ * def __releasebuffer__(ndarray self, Py_buffer* info):
+ * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<<
+ * PyObject_Free(info.format)
+ * if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ */
+ __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0);
+ if (__pyx_t_1) {
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":339
+ * def __releasebuffer__(ndarray self, Py_buffer* info):
+ * if PyArray_HASFIELDS(self):
+ * PyObject_Free(info.format) # <<<<<<<<<<<<<<
+ * if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ * PyObject_Free(info.strides)
+ */
+ PyObject_Free(__pyx_v_info->format);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":338
+ *
+ * def __releasebuffer__(ndarray self, Py_buffer* info):
+ * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<<
+ * PyObject_Free(info.format)
+ * if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ */
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":340
+ * if PyArray_HASFIELDS(self):
+ * PyObject_Free(info.format)
+ * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<<
+ * PyObject_Free(info.strides)
+ * # info.shape was stored after info.strides in the same block
+ */
+ __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0);
+ if (__pyx_t_1) {
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":341
+ * PyObject_Free(info.format)
+ * if sizeof(npy_intp) != sizeof(Py_ssize_t):
+ * PyObject_Free(info.strides) # <<<<<<<<<<<<<<
+ * # info.shape was stored after info.strides in the same block
+ *
+ */
+ PyObject_Free(__pyx_v_info->strides);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":340
+ * if PyArray_HASFIELDS(self):
+ * PyObject_Free(info.format)
+ * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<<
+ * PyObject_Free(info.strides)
+ * # info.shape was stored after info.strides in the same block
+ */
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":337
+ * f[0] = c'\0' # Terminate format string
+ *
+ * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<<
+ * if PyArray_HASFIELDS(self):
+ * PyObject_Free(info.format)
+ */
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":821
+ * ctypedef npy_cdouble complex_t
+ *
+ * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<<
+ * return PyArray_MultiIterNew(1, a)
+ *
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":822
+ *
+ * cdef inline object PyArray_MultiIterNew1(a):
+ * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<<
+ *
+ * cdef inline object PyArray_MultiIterNew2(a, b):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 822, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":821
+ * ctypedef npy_cdouble complex_t
+ *
+ * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<<
+ * return PyArray_MultiIterNew(1, a)
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":824
+ * return PyArray_MultiIterNew(1, a)
+ *
+ * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<<
+ * return PyArray_MultiIterNew(2, a, b)
+ *
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":825
+ *
+ * cdef inline object PyArray_MultiIterNew2(a, b):
+ * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<<
+ *
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 825, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":824
+ * return PyArray_MultiIterNew(1, a)
+ *
+ * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<<
+ * return PyArray_MultiIterNew(2, a, b)
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":827
+ * return PyArray_MultiIterNew(2, a, b)
+ *
+ * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<<
+ * return PyArray_MultiIterNew(3, a, b, c)
+ *
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":828
+ *
+ * cdef inline object PyArray_MultiIterNew3(a, b, c):
+ * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<<
+ *
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 828, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":827
+ * return PyArray_MultiIterNew(2, a, b)
+ *
+ * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<<
+ * return PyArray_MultiIterNew(3, a, b, c)
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":830
+ * return PyArray_MultiIterNew(3, a, b, c)
+ *
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<<
+ * return PyArray_MultiIterNew(4, a, b, c, d)
+ *
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":831
+ *
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d):
+ * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<<
+ *
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 831, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":830
+ * return PyArray_MultiIterNew(3, a, b, c)
+ *
+ * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<<
+ * return PyArray_MultiIterNew(4, a, b, c, d)
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":833
+ * return PyArray_MultiIterNew(4, a, b, c, d)
+ *
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<<
+ * return PyArray_MultiIterNew(5, a, b, c, d, e)
+ *
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":834
+ *
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
+ * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<<
+ *
+ * cdef inline tuple PyDataType_SHAPE(dtype d):
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 834, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_1);
+ __pyx_r = __pyx_t_1;
+ __pyx_t_1 = 0;
+ goto __pyx_L0;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":833
+ * return PyArray_MultiIterNew(4, a, b, c, d)
+ *
+ * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<<
+ * return PyArray_MultiIterNew(5, a, b, c, d, e)
+ *
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = 0;
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":836
+ * return PyArray_MultiIterNew(5, a, b, c, d, e)
+ *
+ * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<<
+ * if PyDataType_HASSUBARRAY(d):
+ * return d.subarray.shape
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) {
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":837
+ *
+ * cdef inline tuple PyDataType_SHAPE(dtype d):
+ * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<<
+ * return d.subarray.shape
+ * else:
+ */
+ __pyx_t_1 = (PyDataType_HASSUBARRAY(__pyx_v_d) != 0);
+ if (__pyx_t_1) {
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":838
+ * cdef inline tuple PyDataType_SHAPE(dtype d):
+ * if PyDataType_HASSUBARRAY(d):
+ * return d.subarray.shape # <<<<<<<<<<<<<<
+ * else:
+ * return ()
+ */
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(((PyObject*)__pyx_v_d->subarray->shape));
+ __pyx_r = ((PyObject*)__pyx_v_d->subarray->shape);
+ goto __pyx_L0;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":837
+ *
+ * cdef inline tuple PyDataType_SHAPE(dtype d):
+ * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<<
+ * return d.subarray.shape
+ * else:
+ */
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":840
+ * return d.subarray.shape
+ * else:
+ * return () # <<<<<<<<<<<<<<
+ *
+ * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL:
+ */
+ /*else*/ {
+ __Pyx_XDECREF(__pyx_r);
+ __Pyx_INCREF(__pyx_empty_tuple);
+ __pyx_r = __pyx_empty_tuple;
+ goto __pyx_L0;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":836
+ * return PyArray_MultiIterNew(5, a, b, c, d, e)
+ *
+ * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<<
+ * if PyDataType_HASSUBARRAY(d):
+ * return d.subarray.shape
+ */
+
+ /* function exit code */
+ __pyx_L0:;
+ __Pyx_XGIVEREF(__pyx_r);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":842
+ * return ()
+ *
+ * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<<
+ * # Recursive utility function used in __getbuffer__ to get format
+ * # string. The new location in the format string is returned.
+ */
+
+static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) {
+ PyArray_Descr *__pyx_v_child = 0;
+ int __pyx_v_endian_detector;
+ int __pyx_v_little_endian;
+ PyObject *__pyx_v_fields = 0;
+ PyObject *__pyx_v_childname = NULL;
+ PyObject *__pyx_v_new_offset = NULL;
+ PyObject *__pyx_v_t = NULL;
+ char *__pyx_r;
+ __Pyx_RefNannyDeclarations
+ PyObject *__pyx_t_1 = NULL;
+ Py_ssize_t __pyx_t_2;
+ PyObject *__pyx_t_3 = NULL;
+ PyObject *__pyx_t_4 = NULL;
+ int __pyx_t_5;
+ int __pyx_t_6;
+ int __pyx_t_7;
+ long __pyx_t_8;
+ char *__pyx_t_9;
+ __Pyx_RefNannySetupContext("_util_dtypestring", 0);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":847
+ *
+ * cdef dtype child
+ * cdef int endian_detector = 1 # <<<<<<<<<<<<<<
+ * cdef bint little_endian = ((&endian_detector)[0] != 0)
+ * cdef tuple fields
+ */
+ __pyx_v_endian_detector = 1;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":848
+ * cdef dtype child
+ * cdef int endian_detector = 1
+ * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<<
+ * cdef tuple fields
+ *
+ */
+ __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":851
+ * cdef tuple fields
+ *
+ * for childname in descr.names: # <<<<<<<<<<<<<<
+ * fields = descr.fields[childname]
+ * child, new_offset = fields
+ */
+ if (unlikely(__pyx_v_descr->names == Py_None)) {
+ PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
+ __PYX_ERR(1, 851, __pyx_L1_error)
+ }
+ __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
+ for (;;) {
+ if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 851, __pyx_L1_error)
+ #else
+ __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 851, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ #endif
+ __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3);
+ __pyx_t_3 = 0;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":852
+ *
+ * for childname in descr.names:
+ * fields = descr.fields[childname] # <<<<<<<<<<<<<<
+ * child, new_offset = fields
+ *
+ */
+ if (unlikely(__pyx_v_descr->fields == Py_None)) {
+ PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
+ __PYX_ERR(1, 852, __pyx_L1_error)
+ }
+ __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 852, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) __PYX_ERR(1, 852, __pyx_L1_error)
+ __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3));
+ __pyx_t_3 = 0;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":853
+ * for childname in descr.names:
+ * fields = descr.fields[childname]
+ * child, new_offset = fields # <<<<<<<<<<<<<<
+ *
+ * if (end - f) - (new_offset - offset[0]) < 15:
+ */
+ if (likely(__pyx_v_fields != Py_None)) {
+ PyObject* sequence = __pyx_v_fields;
+ Py_ssize_t size = __Pyx_PySequence_SIZE(sequence);
+ if (unlikely(size != 2)) {
+ if (size > 2) __Pyx_RaiseTooManyValuesError(2);
+ else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
+ __PYX_ERR(1, 853, __pyx_L1_error)
+ }
+ #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+ __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0);
+ __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1);
+ __Pyx_INCREF(__pyx_t_3);
+ __Pyx_INCREF(__pyx_t_4);
+ #else
+ __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 853, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 853, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ #endif
+ } else {
+ __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 853, __pyx_L1_error)
+ }
+ if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) __PYX_ERR(1, 853, __pyx_L1_error)
+ __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3));
+ __pyx_t_3 = 0;
+ __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4);
+ __pyx_t_4 = 0;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":855
+ * child, new_offset = fields
+ *
+ * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<<
+ * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ *
+ */
+ __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 855, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 855, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 855, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0);
+ if (unlikely(__pyx_t_6)) {
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":856
+ *
+ * if (end - f) - (new_offset - offset[0]) < 15:
+ * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<<
+ *
+ * if ((child.byteorder == c'>' and little_endian) or
+ */
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 856, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(1, 856, __pyx_L1_error)
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":855
+ * child, new_offset = fields
+ *
+ * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<<
+ * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ *
+ */
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":858
+ * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ *
+ * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<<
+ * (child.byteorder == c'<' and not little_endian)):
+ * raise ValueError(u"Non-native byte order not supported")
+ */
+ __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0);
+ if (!__pyx_t_7) {
+ goto __pyx_L8_next_or;
+ } else {
+ }
+ __pyx_t_7 = (__pyx_v_little_endian != 0);
+ if (!__pyx_t_7) {
+ } else {
+ __pyx_t_6 = __pyx_t_7;
+ goto __pyx_L7_bool_binop_done;
+ }
+ __pyx_L8_next_or:;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":859
+ *
+ * if ((child.byteorder == c'>' and little_endian) or
+ * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<<
+ * raise ValueError(u"Non-native byte order not supported")
+ * # One could encode it in the format string and have Cython
+ */
+ __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0);
+ if (__pyx_t_7) {
+ } else {
+ __pyx_t_6 = __pyx_t_7;
+ goto __pyx_L7_bool_binop_done;
+ }
+ __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0);
+ __pyx_t_6 = __pyx_t_7;
+ __pyx_L7_bool_binop_done:;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":858
+ * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ *
+ * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<<
+ * (child.byteorder == c'<' and not little_endian)):
+ * raise ValueError(u"Non-native byte order not supported")
+ */
+ if (unlikely(__pyx_t_6)) {
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":860
+ * if ((child.byteorder == c'>' and little_endian) or
+ * (child.byteorder == c'<' and not little_endian)):
+ * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<<
+ * # One could encode it in the format string and have Cython
+ * # complain instead, BUT: < and > in format strings also imply
+ */
+ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 860, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __Pyx_Raise(__pyx_t_3, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __PYX_ERR(1, 860, __pyx_L1_error)
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":858
+ * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd")
+ *
+ * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<<
+ * (child.byteorder == c'<' and not little_endian)):
+ * raise ValueError(u"Non-native byte order not supported")
+ */
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":870
+ *
+ * # Output padding bytes
+ * while offset[0] < new_offset: # <<<<<<<<<<<<<<
+ * f[0] = 120 # "x"; pad byte
+ * f += 1
+ */
+ while (1) {
+ __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 870, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 870, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 870, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ if (!__pyx_t_6) break;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":871
+ * # Output padding bytes
+ * while offset[0] < new_offset:
+ * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<<
+ * f += 1
+ * offset[0] += 1
+ */
+ (__pyx_v_f[0]) = 0x78;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":872
+ * while offset[0] < new_offset:
+ * f[0] = 120 # "x"; pad byte
+ * f += 1 # <<<<<<<<<<<<<<
+ * offset[0] += 1
+ *
+ */
+ __pyx_v_f = (__pyx_v_f + 1);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":873
+ * f[0] = 120 # "x"; pad byte
+ * f += 1
+ * offset[0] += 1 # <<<<<<<<<<<<<<
+ *
+ * offset[0] += child.itemsize
+ */
+ __pyx_t_8 = 0;
+ (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1);
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":875
+ * offset[0] += 1
+ *
+ * offset[0] += child.itemsize # <<<<<<<<<<<<<<
+ *
+ * if not PyDataType_HASFIELDS(child):
+ */
+ __pyx_t_8 = 0;
+ (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":877
+ * offset[0] += child.itemsize
+ *
+ * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<<
+ * t = child.type_num
+ * if end - f < 5:
+ */
+ __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0);
+ if (__pyx_t_6) {
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":878
+ *
+ * if not PyDataType_HASFIELDS(child):
+ * t = child.type_num # <<<<<<<<<<<<<<
+ * if end - f < 5:
+ * raise RuntimeError(u"Format string allocated too short.")
+ */
+ __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 878, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4);
+ __pyx_t_4 = 0;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":879
+ * if not PyDataType_HASFIELDS(child):
+ * t = child.type_num
+ * if end - f < 5: # <<<<<<<<<<<<<<
+ * raise RuntimeError(u"Format string allocated too short.")
+ *
+ */
+ __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0);
+ if (unlikely(__pyx_t_6)) {
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":880
+ * t = child.type_num
+ * if end - f < 5:
+ * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<<
+ *
+ * # Until ticket #99 is fixed, use integers to avoid warnings
+ */
+ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 880, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __PYX_ERR(1, 880, __pyx_L1_error)
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":879
+ * if not PyDataType_HASFIELDS(child):
+ * t = child.type_num
+ * if end - f < 5: # <<<<<<<<<<<<<<
+ * raise RuntimeError(u"Format string allocated too short.")
+ *
+ */
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":883
+ *
+ * # Until ticket #99 is fixed, use integers to avoid warnings
+ * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<<
+ * elif t == NPY_UBYTE: f[0] = 66 #"B"
+ * elif t == NPY_SHORT: f[0] = 104 #"h"
+ */
+ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 883, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 883, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 883, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ if (__pyx_t_6) {
+ (__pyx_v_f[0]) = 98;
+ goto __pyx_L15;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":884
+ * # Until ticket #99 is fixed, use integers to avoid warnings
+ * if t == NPY_BYTE: f[0] = 98 #"b"
+ * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<<
+ * elif t == NPY_SHORT: f[0] = 104 #"h"
+ * elif t == NPY_USHORT: f[0] = 72 #"H"
+ */
+ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 884, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 884, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 884, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ if (__pyx_t_6) {
+ (__pyx_v_f[0]) = 66;
+ goto __pyx_L15;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":885
+ * if t == NPY_BYTE: f[0] = 98 #"b"
+ * elif t == NPY_UBYTE: f[0] = 66 #"B"
+ * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<<
+ * elif t == NPY_USHORT: f[0] = 72 #"H"
+ * elif t == NPY_INT: f[0] = 105 #"i"
+ */
+ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 885, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 885, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 885, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ if (__pyx_t_6) {
+ (__pyx_v_f[0]) = 0x68;
+ goto __pyx_L15;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":886
+ * elif t == NPY_UBYTE: f[0] = 66 #"B"
+ * elif t == NPY_SHORT: f[0] = 104 #"h"
+ * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<<
+ * elif t == NPY_INT: f[0] = 105 #"i"
+ * elif t == NPY_UINT: f[0] = 73 #"I"
+ */
+ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 886, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 886, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 886, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ if (__pyx_t_6) {
+ (__pyx_v_f[0]) = 72;
+ goto __pyx_L15;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":887
+ * elif t == NPY_SHORT: f[0] = 104 #"h"
+ * elif t == NPY_USHORT: f[0] = 72 #"H"
+ * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<<
+ * elif t == NPY_UINT: f[0] = 73 #"I"
+ * elif t == NPY_LONG: f[0] = 108 #"l"
+ */
+ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 887, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 887, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 887, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ if (__pyx_t_6) {
+ (__pyx_v_f[0]) = 0x69;
+ goto __pyx_L15;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":888
+ * elif t == NPY_USHORT: f[0] = 72 #"H"
+ * elif t == NPY_INT: f[0] = 105 #"i"
+ * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<<
+ * elif t == NPY_LONG: f[0] = 108 #"l"
+ * elif t == NPY_ULONG: f[0] = 76 #"L"
+ */
+ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 888, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 888, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 888, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ if (__pyx_t_6) {
+ (__pyx_v_f[0]) = 73;
+ goto __pyx_L15;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":889
+ * elif t == NPY_INT: f[0] = 105 #"i"
+ * elif t == NPY_UINT: f[0] = 73 #"I"
+ * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<<
+ * elif t == NPY_ULONG: f[0] = 76 #"L"
+ * elif t == NPY_LONGLONG: f[0] = 113 #"q"
+ */
+ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 889, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 889, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 889, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ if (__pyx_t_6) {
+ (__pyx_v_f[0]) = 0x6C;
+ goto __pyx_L15;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":890
+ * elif t == NPY_UINT: f[0] = 73 #"I"
+ * elif t == NPY_LONG: f[0] = 108 #"l"
+ * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<<
+ * elif t == NPY_LONGLONG: f[0] = 113 #"q"
+ * elif t == NPY_ULONGLONG: f[0] = 81 #"Q"
+ */
+ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 890, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 890, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 890, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ if (__pyx_t_6) {
+ (__pyx_v_f[0]) = 76;
+ goto __pyx_L15;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":891
+ * elif t == NPY_LONG: f[0] = 108 #"l"
+ * elif t == NPY_ULONG: f[0] = 76 #"L"
+ * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<<
+ * elif t == NPY_ULONGLONG: f[0] = 81 #"Q"
+ * elif t == NPY_FLOAT: f[0] = 102 #"f"
+ */
+ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 891, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 891, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 891, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ if (__pyx_t_6) {
+ (__pyx_v_f[0]) = 0x71;
+ goto __pyx_L15;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":892
+ * elif t == NPY_ULONG: f[0] = 76 #"L"
+ * elif t == NPY_LONGLONG: f[0] = 113 #"q"
+ * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<<
+ * elif t == NPY_FLOAT: f[0] = 102 #"f"
+ * elif t == NPY_DOUBLE: f[0] = 100 #"d"
+ */
+ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 892, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 892, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 892, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ if (__pyx_t_6) {
+ (__pyx_v_f[0]) = 81;
+ goto __pyx_L15;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":893
+ * elif t == NPY_LONGLONG: f[0] = 113 #"q"
+ * elif t == NPY_ULONGLONG: f[0] = 81 #"Q"
+ * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<<
+ * elif t == NPY_DOUBLE: f[0] = 100 #"d"
+ * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g"
+ */
+ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 893, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 893, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 893, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ if (__pyx_t_6) {
+ (__pyx_v_f[0]) = 0x66;
+ goto __pyx_L15;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":894
+ * elif t == NPY_ULONGLONG: f[0] = 81 #"Q"
+ * elif t == NPY_FLOAT: f[0] = 102 #"f"
+ * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<<
+ * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g"
+ * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf
+ */
+ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 894, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 894, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 894, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ if (__pyx_t_6) {
+ (__pyx_v_f[0]) = 0x64;
+ goto __pyx_L15;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":895
+ * elif t == NPY_FLOAT: f[0] = 102 #"f"
+ * elif t == NPY_DOUBLE: f[0] = 100 #"d"
+ * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<<
+ * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf
+ * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd
+ */
+ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 895, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 895, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 895, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ if (__pyx_t_6) {
+ (__pyx_v_f[0]) = 0x67;
+ goto __pyx_L15;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":896
+ * elif t == NPY_DOUBLE: f[0] = 100 #"d"
+ * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g"
+ * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<<
+ * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd
+ * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
+ */
+ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 896, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 896, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 896, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ if (__pyx_t_6) {
+ (__pyx_v_f[0]) = 90;
+ (__pyx_v_f[1]) = 0x66;
+ __pyx_v_f = (__pyx_v_f + 1);
+ goto __pyx_L15;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":897
+ * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g"
+ * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf
+ * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<<
+ * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
+ * elif t == NPY_OBJECT: f[0] = 79 #"O"
+ */
+ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 897, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 897, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 897, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ if (__pyx_t_6) {
+ (__pyx_v_f[0]) = 90;
+ (__pyx_v_f[1]) = 0x64;
+ __pyx_v_f = (__pyx_v_f + 1);
+ goto __pyx_L15;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":898
+ * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf
+ * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd
+ * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<<
+ * elif t == NPY_OBJECT: f[0] = 79 #"O"
+ * else:
+ */
+ __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 898, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 898, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 898, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ if (__pyx_t_6) {
+ (__pyx_v_f[0]) = 90;
+ (__pyx_v_f[1]) = 0x67;
+ __pyx_v_f = (__pyx_v_f + 1);
+ goto __pyx_L15;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":899
+ * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd
+ * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg
+ * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<<
+ * else:
+ * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ */
+ __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 899, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 899, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 899, __pyx_L1_error)
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ if (likely(__pyx_t_6)) {
+ (__pyx_v_f[0]) = 79;
+ goto __pyx_L15;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":901
+ * elif t == NPY_OBJECT: f[0] = 79 #"O"
+ * else:
+ * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<<
+ * f += 1
+ * else:
+ */
+ /*else*/ {
+ __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 901, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_3);
+ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 901, __pyx_L1_error)
+ __Pyx_GOTREF(__pyx_t_4);
+ __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
+ __Pyx_Raise(__pyx_t_4, 0, 0, 0);
+ __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
+ __PYX_ERR(1, 901, __pyx_L1_error)
+ }
+ __pyx_L15:;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":902
+ * else:
+ * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t)
+ * f += 1 # <<<<<<<<<<<<<<
+ * else:
+ * # Cython ignores struct boundary information ("T{...}"),
+ */
+ __pyx_v_f = (__pyx_v_f + 1);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":877
+ * offset[0] += child.itemsize
+ *
+ * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<<
+ * t = child.type_num
+ * if end - f < 5:
+ */
+ goto __pyx_L13;
+ }
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":906
+ * # Cython ignores struct boundary information ("T{...}"),
+ * # so don't output it
+ * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<<
+ * return f
+ *
+ */
+ /*else*/ {
+ __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == ((char *)NULL))) __PYX_ERR(1, 906, __pyx_L1_error)
+ __pyx_v_f = __pyx_t_9;
+ }
+ __pyx_L13:;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":851
+ * cdef tuple fields
+ *
+ * for childname in descr.names: # <<<<<<<<<<<<<<
+ * fields = descr.fields[childname]
+ * child, new_offset = fields
+ */
+ }
+ __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":907
+ * # so don't output it
+ * f = _util_dtypestring(child, f, end, offset)
+ * return f # <<<<<<<<<<<<<<
+ *
+ *
+ */
+ __pyx_r = __pyx_v_f;
+ goto __pyx_L0;
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":842
+ * return ()
+ *
+ * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<<
+ * # Recursive utility function used in __getbuffer__ to get format
+ * # string. The new location in the format string is returned.
+ */
+
+ /* function exit code */
+ __pyx_L1_error:;
+ __Pyx_XDECREF(__pyx_t_1);
+ __Pyx_XDECREF(__pyx_t_3);
+ __Pyx_XDECREF(__pyx_t_4);
+ __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename);
+ __pyx_r = NULL;
+ __pyx_L0:;
+ __Pyx_XDECREF((PyObject *)__pyx_v_child);
+ __Pyx_XDECREF(__pyx_v_fields);
+ __Pyx_XDECREF(__pyx_v_childname);
+ __Pyx_XDECREF(__pyx_v_new_offset);
+ __Pyx_XDECREF(__pyx_v_t);
+ __Pyx_RefNannyFinishContext();
+ return __pyx_r;
+}
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1022
+ * int _import_umath() except -1
+ *
+ * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<<
+ * Py_INCREF(base) # important to do this before stealing the reference below!
+ * PyArray_SetBaseObject(arr, base)
+ */
+
+static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) {
+ __Pyx_RefNannyDeclarations
+ __Pyx_RefNannySetupContext("set_array_base", 0);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1023
+ *
+ * cdef inline void set_array_base(ndarray arr, object base):
+ * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<<
+ * PyArray_SetBaseObject(arr, base)
+ *
+ */
+ Py_INCREF(__pyx_v_base);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1024
+ * cdef inline void set_array_base(ndarray arr, object base):
+ * Py_INCREF(base) # important to do this before stealing the reference below!
+ * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<<
+ *
+ * cdef inline object get_array_base(ndarray arr):
+ */
+ (void)(PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base));
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1022
+ * int _import_umath() except -1
+ *
+ * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<<
+ * Py_INCREF(base) # important to do this before stealing the reference below!
+ * PyArray_SetBaseObject(arr, base)
+ */
+
+ /* function exit code */
+ __Pyx_RefNannyFinishContext();
+}
+
+/* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1026
+ * PyArray_SetBaseObject(arr, base)
+ *
+ * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<<
+ * base = PyArray_BASE(arr)
+ * if base is NULL:
+ */
+
+static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) {
+ PyObject *__pyx_v_base;
+ PyObject *__pyx_r = NULL;
+ __Pyx_RefNannyDeclarations
+ int __pyx_t_1;
+ __Pyx_RefNannySetupContext("get_array_base", 0);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1027
+ *
+ * cdef inline object get_array_base(ndarray arr):
+ * base = PyArray_BASE(arr) # <<<<<<<<<<<<<<
+ * if base is NULL:
+ * return None
+ */
+ __pyx_v_base = PyArray_BASE(__pyx_v_arr);
+
+ /* "../../../../../anaconda3/envs/CenterNet/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1028
+ * cdef inline object get_array_base(ndarray arr):
+ * base = PyArray_BASE(arr)
+ * if base is NULL: # <<<<<<<<<<<<<<
+ * return None
+ * return