From 2bc479f16aa3db046f9ce1dfb3a5fcac52536c2e Mon Sep 17 00:00:00 2001 From: LukasBommes Date: Wed, 8 Jan 2020 16:09:41 +0800 Subject: [PATCH 1/6] added Docker environment --- Dockerfile | 46 + docker-compose-new.yml | 16 + docker-compose.yml | 15 + docker-entrypoint.sh | 21 + install.sh | 92 + lib/make.sh | 0 lib/model/nms/.gitignore | 10 +- lib/model/nms/make.sh | 0 lib/model/nms/src/nms_cuda.c | 19 + lib/model/nms/src/nms_cuda_kernel.cu.o | Bin 33568 -> 36352 bytes .../psroi_pooling/src/cuda/psroi_pooling.cu.o | Bin 24448 -> 0 bytes lib/model/roi_align/install.sh | 0 .../roi_crop/src/roi_crop_cuda_kernel.cu.o | Bin 25248 -> 0 bytes lib/model/utils/.gitignore | 3 - lib/model/utils/bbox.c | 9430 +++++++++++++++++ pytorch-coviar | 1 + requirements.txt | 10 + tracking_on_mot.py | 8 +- 18 files changed, 9662 insertions(+), 9 deletions(-) create mode 100644 Dockerfile create mode 100755 docker-compose-new.yml create mode 100755 docker-compose.yml create mode 100755 docker-entrypoint.sh create mode 100755 install.sh mode change 100644 => 100755 lib/make.sh mode change 100644 => 100755 lib/model/nms/make.sh create mode 100644 lib/model/nms/src/nms_cuda.c delete mode 100644 lib/model/psroi_pooling/src/cuda/psroi_pooling.cu.o mode change 100644 => 100755 lib/model/roi_align/install.sh delete mode 100644 lib/model/roi_crop/src/roi_crop_cuda_kernel.cu.o delete mode 100644 lib/model/utils/.gitignore create mode 100644 lib/model/utils/bbox.c create mode 160000 pytorch-coviar create mode 100755 requirements.txt diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..ca47239 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,46 @@ +FROM nvidia/cuda:8.0-cudnn6-devel-ubuntu16.04 + +RUN apt-get update && \ + apt-get install -y software-properties-common + +RUN add-apt-repository ppa:deadsnakes/ppa && \ + apt-get update && apt-get install -y \ + pkg-config \ + python3.6-dev \ + python3-pip && \ + rm -rf /var/lib/apt/lists/* + +RUN update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.6 1 + +RUN ln -s $(which python3.6) /usr/local/bin/python + +RUN pip3 install numpy pkgconfig + + +WORKDIR /workspace +RUN chmod -R a+w /workspace + +# Install coviar +WORKDIR /workspace/pytorch-coviar +COPY pytorch-coviar . +WORKDIR /workspace +COPY install.sh . +RUN chmod +x install.sh && \ + ./install.sh + +# Set environment variables +ENV PKG_CONFIG_PATH="$PKG_CONFIG_PATH:/ffmpeg_build/lib/pkgconfig" +ENV LD_LIBRARY_PATH="$LD_LIBRARY_PATH":/ffmpeg_build/lib + +WORKDIR /workspace/pytorch-coviar/data_loader +RUN chmod +x install.sh && \ + ./install.sh + +WORKDIR /workspace + +# Install Python packages +COPY requirements.txt / +RUN pip3 install --upgrade pip +RUN pip3 install -r /requirements.txt + +CMD ["sh", "-c", "tail -f /dev/null"] diff --git a/docker-compose-new.yml b/docker-compose-new.yml new file mode 100755 index 0000000..fbbcb25 --- /dev/null +++ b/docker-compose-new.yml @@ -0,0 +1,16 @@ +version: "2.3" + +services: + + otcd_pytorch_1_3: + container_name: otcd_pytorch_1_3 + image: pytorch6 + runtime: nvidia + environment: + - DISPLAY + ipc: host # for GUI + volumes: + - /tmp/.X11-unix:/tmp/.X11-unix:rw # for GUI access + - .:/workspace + entrypoint: ./docker-entrypoint.sh + command: tail -f /dev/null diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100755 index 0000000..729a0fa --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,15 @@ +version: "2.3" + +services: + + otcd: + container_name: otcd + build: . + runtime: nvidia + environment: + - DISPLAY + ipc: host # for GUI + volumes: + - /tmp/.X11-unix:/tmp/.X11-unix:rw # for GUI access + - .:/workspace + - /home/lukas/mv-tracker/data:/workspace/data diff --git a/docker-entrypoint.sh b/docker-entrypoint.sh new file mode 100755 index 0000000..34cb98f --- /dev/null +++ b/docker-entrypoint.sh @@ -0,0 +1,21 @@ +#!/bin/sh +set -e + +conda install -y av -c conda-forge # needed to fix ffmpeg error during torchvision build +export FORCE_CUDA=1 +cd /opt/pytorch +rm -rf vision +git config --global user.email "Lukas.Bommes@gmx.de" +git config --global user.name "LukasBommes" +git clone https://github.com/LukasBommes/vision.git +cd vision +pip install -v . +cd /workspace + +# temporary workaround for torchvision issue #1712 (incompatibility with pillow 7.0.0) +pip install 'pillow<7' + +# install coviar +cd /workspace && chmod +x install.sh && ./install.sh + +exec "$@" diff --git a/install.sh b/install.sh new file mode 100755 index 0000000..c71ce87 --- /dev/null +++ b/install.sh @@ -0,0 +1,92 @@ +#!/bin/bash + +INSTALL_BASE_DIR="$PWD/.." +INSTALL_DIR="$PWD" + +echo "Installing module into: $INSTALL_DIR" + +# Install build tools +apt-get update && \ +apt-get upgrade -y && \ +apt-get install -y \ + wget \ + unzip \ + build-essential \ + cmake \ + git \ + pkg-config \ + autoconf \ + automake \ + git-core \ + python3-dev \ + python3-pip \ + python3-numpy \ + python3-pkgconfig && \ + rm -rf /var/lib/apt/lists/* + + +############################################################################### +# +# FFMPEG +# +############################################################################### + +# Install FFMPEG dependencies +apt-get update -qq && \ +apt-get -y install \ + libass-dev \ + libfreetype6-dev \ + libsdl2-dev \ + libtool \ + libva-dev \ + libvdpau-dev \ + libvorbis-dev \ + libxcb1-dev \ + libxcb-shm0-dev \ + libxcb-xfixes0-dev \ + texinfo \ + zlib1g-dev \ + nasm \ + yasm \ + libx264-dev \ + libx265-dev \ + libnuma-dev \ + libvpx-dev \ + libfdk-aac-dev \ + libmp3lame-dev \ + libopus-dev + + +# Download FFMPEG source +FFMPEG_VERSION="4.1.3" +mkdir -p "$INSTALL_BASE_DIR"/ffmpeg_sources/ffmpeg "$INSTALL_BASE_DIR"/bin +cd "$INSTALL_BASE_DIR"/ffmpeg_sources +wget -O ffmpeg-snapshot.tar.bz2 https://ffmpeg.org/releases/ffmpeg-"$FFMPEG_VERSION".tar.bz2 +tar xjvf ffmpeg-snapshot.tar.bz2 -C "$INSTALL_BASE_DIR"/ffmpeg_sources/ffmpeg --strip-components=1 +rm -rf "$INSTALL_BASE_DIR"/ffmpeg_sources/ffmpeg-snapshot.tar.bz2 +cd "$INSTALL_BASE_DIR"/ffmpeg_sources/ffmpeg + +# Compile FFMPEG +cd "$INSTALL_BASE_DIR"/ffmpeg_sources/ffmpeg && \ +./configure \ +--prefix="$INSTALL_BASE_DIR/ffmpeg_build" \ +--pkg-config-flags="--static" \ +--extra-cflags="-I$INSTALL_BASE_DIR/ffmpeg_build/include" \ +--extra-ldflags="-L$INSTALL_BASE_DIR/ffmpeg_build/lib" \ +--extra-libs="-lpthread -lm" \ +--bindir="$INSTALL_BASE_DIR/bin" \ +--enable-gpl \ +--enable-libass \ +--enable-libfdk-aac \ +--enable-libfreetype \ +--enable-libmp3lame \ +--enable-libopus \ +--enable-libvorbis \ +--enable-libvpx \ +--enable-libx264 \ +--enable-libx265 \ +--enable-nonfree \ +--enable-pic && \ +make -j $(nproc) && \ +make install && \ +hash -r diff --git a/lib/make.sh b/lib/make.sh old mode 100644 new mode 100755 diff --git a/lib/model/nms/.gitignore b/lib/model/nms/.gitignore index 15a165d..c45a1ab 100644 --- a/lib/model/nms/.gitignore +++ b/lib/model/nms/.gitignore @@ -1,3 +1,9 @@ -*.c -*.cpp +.idea +.vscode* *.so +*.o +*.pyc +build/ +roi_align.egg-info/ +dist/ +.DS_Store diff --git a/lib/model/nms/make.sh b/lib/model/nms/make.sh old mode 100644 new mode 100755 diff --git a/lib/model/nms/src/nms_cuda.c b/lib/model/nms/src/nms_cuda.c new file mode 100644 index 0000000..3667c7d --- /dev/null +++ b/lib/model/nms/src/nms_cuda.c @@ -0,0 +1,19 @@ +#include +#include +#include "nms_cuda_kernel.h" + +// this symbol will be resolved automatically from PyTorch libs +extern THCState *state; + +int nms_cuda(THCudaIntTensor *keep_out, THCudaTensor *boxes_host, + THCudaIntTensor *num_out, float nms_overlap_thresh) { + + nms_cuda_compute(THCudaIntTensor_data(state, keep_out), + THCudaIntTensor_data(state, num_out), + THCudaTensor_data(state, boxes_host), + THCudaTensor_size(state, boxes_host, 0), + THCudaTensor_size(state, boxes_host, 1), + nms_overlap_thresh); + + return 1; +} diff --git a/lib/model/nms/src/nms_cuda_kernel.cu.o b/lib/model/nms/src/nms_cuda_kernel.cu.o index 10871af642518b45c4276cfd4077719c58f397d7..56e59f5bfd3409b6da821eda9bf799d3ca0442f5 100644 GIT binary patch literal 36352 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 WU(A=lb$(*B1g`ZtRsz@gkN*q033hM* diff --git a/lib/model/roi_align/install.sh b/lib/model/roi_align/install.sh old mode 100644 new mode 100755 diff --git a/lib/model/roi_crop/src/roi_crop_cuda_kernel.cu.o b/lib/model/roi_crop/src/roi_crop_cuda_kernel.cu.o deleted file mode 100644 index 9dd6c6b79610e97f62b9fb46554d767b8d3139ee..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 25248 zcmeHve{kGIc4yD`E6rD)-!mFXBV(h1HAt|mEE|K2Ygxu%St7``4lHbt_C~TLOJXfq zNF!_#v<$UuY-K`lrP#x{+GLef61%Q)x6akx;Z<;ImUyvK;i|j|b*3(xi!m(rF5WE( z4EEj{=|1mu_vouH^VKHCx!XUst7iJ!uV24@{od=>@Adq6wyAZa;qeGvJmO1YzNMk4 zH_kt&_%S6aM2vC0Xt%da{HSGO{7Or%=}OB)DPes1Zy5Nsiwz%!qfHkl#xJx?jGb+n zXn*Tu(^Z-y*K~E_=dF^{wd=sx@$l3WJ8oMQT{17O#`V4^I4i z{V_m6^YX;&ykgM#`d~fZ{Ue!L7IAX#Zi7bhNmO^^eUbv>FM}cyrXf58$=ilQe*Bo(MIC{H;6nMSya$& zo+>D6U+y@~fv4fzahd~9{kh{b2cEie$0y~}c5R)2wn@c9#iaO@R6MMM6i?Ox#glbt zTS^veDN(Q`mV@b`@(qS0vhDB)S{l3 zL=sbVgj9UtT@oibb%#677bQ;JRD(NCLgF+`t#QY>gdGMUubo;;IK_p0TH>UpQtovA zLgKVcZE(jqAaUBJTHJAZB+mA!R(G6~#Oa!9bH`aGar&pWy5n3y7uG&JwcQ=(O^LH_ zs?!~ZHhjwqU(ceN>cX3gS|`v2v;&0JMI(rJVX@^CG9L*i3;!-9K)FU%5{4@q)Q{qRnx zx}?9uAxZuY-j5DCcrNmH@P6d&;Qdml$os98-fz4C?PPAe4i(PEBq}()1S)cR@Hhph z_ZgkdKVvKYGH3Hw5@%6o^RmQQ)Y*(moJF0@7KyW{v-v!57Iij0Nn}xH^PcpMi#nUv zB+jDF=8q)KqR!?wCC;MG=23~WsIyruaTawpA&Il7v-yd1kc&E-*Cmc}HrP2uPN6@M zIQ@$`lCMgf;l&)u;}U1zVqWBK#*xmZ2i&+go3KP`v`_5{+F> z#vScHO0-E}Ozm?=8%YTc|UUEZ|F8?gykbsLaX1q@>{{rEB(;dg%*j6)3CtTgJ*d1V19tNC+xo z)*(27K;QuPki5~zqCz-LFgh!K*|CG;qKokU?GB!X`S@3zxRi;Xys%@MVrD#_+^`}6 zZUsF=^h23^C|N=E`tS1lF+|yOEiVMQ>xBxga(8j1GrsFguW))sR3dpn&L$V~LTNQI zG=Vkb6gRZAGjpeb{ZAjx%`vu(Mj?gJiNO5*#KhR8iS}uv0VI-K`=yD9e3+hSE0IqZ zC)&!s{5QQLBYQ@Y14GIC2X+q(^>&Xu(mgo5yLY61Y`CX8)4OFXGdz}Am%L@vN1O`r zOYoaVx_cfRvJFW;zIx4$?ww!R+da~=V2XjEzJaz~11OKAi@y_;3eU@Q>?~sZ#*saP z%_9RnMd-+p7~A&Kc3gEt#E}LjBMjm3r103U+7c>+h26@jy#lcOb*HUCyh7o_(Tz=&AaF zp7*3AOY5HQ=?H;RJ`+RFvPb6fv1abQ9F27zS2*1uF_7qqJd zQV&~yLhM`6t`bOeZ2gsDctN{D^rL-Kf&aMZS# z1^pq>vY;Il8y2(!ILGb$`f;|~>G{N(1^r7z!-961xMM-v5_JpOUXet5e!Zn)*@FHO zkyy|+MSMZqK&)fu&qFq9qbI09-sTN+qGWjqVT+PwWgNq_!6r*?1Pq2$0(&Y!U&=EK zdm1jtze?<0K);gpGjCrN4*kR(`YCtlC+5&kRBT;9U+Qa~{;%~ludh0rzDTXVF29z* zuO;xSErE}%%oGGv1LMbdCrbU7l0vN8hG6Dgt4~x}G>_p!({rqI zc~xrGlUXJVqZ#PgHq$tdI|s4M^fiiX^l0Zy_;sGY#I!KK=qN>f1a*nIO(cwlj`ytO zZ2m+|qNL<9rjB)%n$3*oMSTExm#kZ7#fchGMr}{B!=!$ruA^j0Ef|Qkp0iS3;=j~) z8S{phExCOg_&C<-HTy)eB;Sd9*IDa?5M{R$f5$qj=C)Z`^D7UT>-M63uJhkn$)AaQ zI$^A92EB8wLAB0+7yM)X8RG9?4R8f6c@CcQ0Zx4RxlVR`Y>8QMDJuwHc)v|o1t^7ITL`}8NE7#}u6CaS1?~KTL1jZY);;m&OfHuj+=Q}A5K`$opkv!M> zwgvh2dk{$;7FlywN5C)T8v!24_v5N0%g5(KTp%KyVdy1m?(Ps4#+Nj=zFnJ~O}$Yg ze34pSPZ%}LEtY+N^$GM_;&K@J?+}s8B2n7VQ9Eg!&6)?>&QbsA8sYUu89xd< z(o+a>6jpO9%ZK}~Fx(fZ@{rsFYLe4A$R`i^SB3h7FeW>_fR~jeJHqSsB7!~FIc-h8 zPx|!(E=ubcc#+_aNIX_}0uZp*7%Dlcl zmUlP~Ia;El0yW8Tn(XIPTEyeqJcq0XtP6Goz4?`%rfYYdqxF@0!9Vc*zE_w|mC@`W zeZFVqNq?RI`iWk-7y4h)&=HS+0C`6spXBZ0#C?fGx#X){*=@jonCX2;{9*r8piSeM zKj^>OyPx$y`l0!)xn{QerT%T6gtwt1Pz63=A2ZgiG+xAkPx7lkU1labVzC(OTaWh= zy+B<@rP6OzK-vrJhsOt&O8#OoX(wK9vuDzm?*#qXJmeo&_E4?#PjrO8uH#7o{+_Q9 zQDqO|thBqO{*$~un!g16Rft*-=|ACZ8LO`KB(bje zx@~N~Z2yq|(q)G|lfisvHO3KL8c%fIvATGFRWcm&DmhgrUiKvYQa<8RT9hw^eJsH^ z)JHHr7=wK)T?C_&er2WfC+H{rmRZJrrWXqy7QzQRMNQ*BBKd4x zCaTnY<-tZz0(=H(A7dXdeds5Vm}Yyf@j-vEd&`pc^Pwf?VBgRmWxA2hDm71e`9E-b zhUCZkmHx%5lH(GI!v5g>RaJhN{T}v*MSeUS>hqAl;rZd;j0*4rd#{~q@n zhW+LBfPOsO=%w?q68zD*R%6I{W~?2oKZE8A|mG23qx^ON10kyiBVO4IJUWL7zh&)5R{p9uRU=}?dD!c1YYp>!smMlJ z&DiBqQ5I=^(nvl`{wro+T=LDIRT&o7@woJVQRQFazGe@dH?*(FE)!~>U9!A5|Ga|s zEA1=phu!=2{#beIZ0b$KA93g% z{Z#`_e!UVk**)PMcs7asmBjw6Nf_})$yarsC+W?12GAzFY3o+6xCH-zw(!(-80*eM zF6TPIk0|pcVgHkme_EK8C&i=(;}UY-xQYFO@gI@@0)Gj#iC#5o;j06G)TZ&jJu432 z{KC1PEfpP=sA+vB)<^U%;ryoa(;w*b9KyL8Q0ofQIe>jIV4JQcc71&#v6f` z*^XjXmh~4PyXJG{2jCy)Jnd&5pPCb=?h`eNUR8y(Tf_Js<6Tnz+3%P8sn($Vx4WZe zZZGeH8S7^DA4cT7H*1N_L8@U_e!ujW*njNb!y(L%{bQQazXu~{IDVX=^+7&?DD(sS z42R|Xript58D9|pW!6!-Kgt7Vyjice2mc-oyiy9eZw`Y$+9!Oz zyirpY3E+GszY_d8?~n4(Nghx81M_<#Xya;Pb0h@+Q`XR7Kydeo?Q3a&MX*0(OgFN{ zhwzo)(E$7%@R)zdKM+2{{QJwGU!%X%x8yL_cM36^I{(V!0oU<#GkQ<+=s#23GbNnPp50j!sdCj zBb}k>VK42^h;fqXy-n*oofctgLqE~jD_Ca)@x@8()9o04|19EPPt34n{Gt2|#go+k zmm+yp97X&WvUp!x#x~eZUq=90^4zmxpwTi>dj=Y7V5eDgXU8vSe#lSa z4|G@&3*!#9`TZov$JYLW{Qsrfq&-y!H%j1Yd!HFj#yc$FB1RAk9gh5osE&;8O1-{xf1`A z?7u@X2{+Zc!y&mI_V3vL(U4r186f`pJ40c)zDw46$j20v4-q^ZmFqLrIz9pAkDBB=N?#ChI_rnt=YCt`BWgZ&XS7Rnu)llkEM5%LF7ybhkj=0v$N zZK!>q&tFsV6;Sf?t9|f+@^6Nr_*3!=_$7Z@etyNDDNZt9e#Orx;XLa{%P$~c-;|#Q zYGJ2h^T*a}EMJq_*q;{Y)A=m(-JK78V!b^lu9E!4jdS4?_$NJxcfw*n(#h1hvzE9j zvdI6!1V7s5tpDHT-!J1@pYrc*@YBBv`F9`qxt9F$G-TV_B{Mu%Aa7LIv;oD;rAx7zqWS@osT>7@R??L{_1?(nTOv^ z=O@lrllZ~;>&(L+7x`JlUqa{O&O99Ue--&lnXoV(=ch9d|4^NuIv=lbf1dh4W2hmJ7reoX^bX;d@yR zd_J~@gwDsEdH77#pEG^G7yA-%OBgl9NpWf;pI=4t&n!3mDj)Z9|9l>jU`L*IIGEqVjQ_ zhX;J%kM5@^K8F9VQTcd9ArF`F#!M~v-%yJD{zL5lNT)Lop9$~c^O55}%wM76zbd*X zK%B+-CG11z$ zdH8&OlE?nh`M5I=$Nme^`Ka^pLLPol+8f6oC%z??1`z+y`W$(<;x7@wy2$OA8pFVD=MUY#?dbGQv59AYn_if^YFKuQ@p=*KJLuJSJV9g)~EAvXC6Ld?Yc_$ zTRIuc@wd*$oq0I# zZ_Mw^k98i-@fG}^&c|yUd3Xi+2jpMDb=c3?4?1tIQh7M*2lij9^6tt?M7*%`8kJ|y zgtH`HQC|M{46m$2#De?3MB);+wSH?={vD#c8~(+b+sk&&_5t}A6__9Pt@GwYLfQe1 zPf`35I>T{)oa@Mzm4*D9^(&%LnNP%2o*P#A^*hpkmQ`h?z3MzW5#1BS9#t-iKwTfe6 zGJe7RR!m%4hP&=&j=#$d#1Y7|W9wdF|N7uS{G2dm;Qdk*;nw615W$88a3t5h~H)nvQM<>J}-{AjOOuIz9Q&8PUr8H zfYZ1tirbJs6CUNyA6m7XKO2buXo$?+U7mv$z(EW8D z@v$FyKi#_<@xy$tZlWeR(ES40ZyfnP#eF9HB(2|~`wV;jZ9@JyPXefET);fZ_}D*J zY5$m{FYKRq{50ErI0k-s{8`YyPiT58RsJ0a;AF)<()oAo+$+2v^!OU&pYnX@lJR#0 z^sztuewkm#?@bGq4MNu z_4$j=m(8WMoEMk#JdrI=8DjSS6T%Zv`Er=^uz`;7?I$50%72l+z<#Qbcg~r}I|GQ{ zk(W~bM(v;Dd;ouml`6jrQ(l_f$@#1B$o!SY*90&gd21u^gt4=uHgEm$bI9+msQ4Ha6x`a zKA%6D=k>9`=NK_J<*Y=94_{ zi{f{HmpT`sFO|TLPKV*Y(Qle(dA=7#j{Czglly1F;E(xF^1Qy_O*~IL`1U-1FX4PN z8`QnSO%hM>q34grS8@M~^nE4F?+c)^&#&-b6cgNUMnE3@ABUy=;C_bhOX9E#%D*cs zYMBo@-;=Pva+MdyvF|uPC;bBNBWnfwuK@1tsO=9yufFVKp^EcpllU=R+7KO3X^~ZdN1|ab_%`nI8Sd;xBBgBOF~{Va*t~)_!%>n)-${^{a1_ za30FhIi5Vf`LOWpi+FAbSY-!67~eMJ7a{R)Al8Q>zim7a^tJ&(^?i{#Q5xt?_kTt9 z(?01WI129--H$f)?V}D97MG*%CD|odm9{?O>8R@aV_LlKGr#GfS*icD>aQikF7)4w z>s8r5t@_>8MDCx;P4uS6ch0Z5LG>@S_qWgYx2gVblHuy{=F7N7mGcj){vX)K8*eZH z;{TxP$Ej=^zr0kBKdSn-QC*<_@cjB!|MwTr&ll)VtA3c!{P<_NTOIi2 zsQ#6T{?$t1cPt~lySw>|=b|3J8R{1GJ4QzfKU>+nre|RA&IeXEJ@Ld7qJCtL#29)i zy{kL3V_*m%8a*&HkV$usjC4OO(rI)K?&%rZ-J2fhQT;zg;Xe_=F(uih*4-v0D1e2uE2{82>K`dz6@H^mKj(zFUdJY0BGwx;Q@K+)%$=0~4fx1x_| zl6l(8dyaW^pL6~@&_Ohv<1eW3YxO`?>-ja9vMXM{vNH|W;~O+U)ebcNTOJzkgeR0z z&N{|B=iiL}V&ku<@y8qtILH5cjHe^Yx&EW~%ZZ)%&h}$KE2h76t4+JwbK-Cd7zQNI<`Pb-2@K9|1 zW!)0vkeZOzPg_Ed*Xt)UbIP7Zrkdy-KS!2T;oZr9G2RI|^^hF0oz4vuI@fQ)%Q-*U zRI&LFwV?y$L5E{<&M&b({Z4o#VrK5sJv5&~s0zs}DoMgui?9)+-(=#8h6RY`i}n-2 z^*VL^EZ~N1UiNw(PUe#l;kPLoo)rt^1dUaeO>?~HZe`s>2G@o z-%xQB$Kk*)gI_F0zs3dL=mP(e3tVIdhxhHuq#ICrdRKSz12w*|COxueAiZ;B&v1I@ zSWkEQE4?E_y}Rq_c~|eM`klkW_?2ku>eU=CQ~cc9lOF6I>h425lA*pkWuFYR`@4sF z5K-^iGvdT*WD29*PobA%@}j71ZBOa>7{6z1aPVpQYt{5f?=J3@>=f^Ax+_h1Ors&q zOF~Hhz!-9X7G{lm?v_36LnFO?1EZPV5ybr6BTu(y26prGYDt_f%r7>*cOcWRat7j4 zE@K1bBI(B;zx$qax~KQ4ft|hS(ahM6^fmsrc9DM>Xu30F zM-5WXFrI$_qD`mwz}7}H18EeZt*Nfxy*qu^U1>KXPd64d@-&Ql75)_>-P72(qo<+! z9@hOTSP(S3fmOK`e~LgBL%>3^2o6R7R4M0OoN^YLG6O9%SE=4r4Sl_tt$T)Bdv|4a z4Lm&XFcjI`y5;`$t?4ZrH$Kv|HNAEH{kVJ)z551e#>O4JnZ3QeL-fZK(D<6svB8IX zd&YM5KGMIbcd+fzU1GuCT)=``wrxn;|4qZbodpT&fjvXJ2KvTEdPxT$ihsP;TBlyD%F^u=jVjLF!zheQD*W(WXoEsaPU+!%r{KWc$@L-!b z>xTsX?YAsT=aJsb*zo$1zA?T^NdJG_pGpXN+iZjf$qeina)Jvo!(X$IIg;R{yP-3V zijIKjSf!&+9e-jSb)r!F7QC+F*H={ZU7Zt7`5qM~9AD<*LU4*XG@TL^8ad$<=Tad! z#X1`QtPOs<4gMn={PQ;W6&sv#MNP+0@dH(KbZdA(!D(LlD;5pkYlGixgVR4sQgQPC zKWuP2{}v%C{FSIR{eTT_=fB1VxAT9Sg3~m_zs`g2wBg(N-)h6BM}3dm?SShDe9#3> z@fQ`U8t~Hmzi5N6vcXT-;CI^K7hK>0#8XtL+m4S^(-^u7r-Hw{;Nrx;YNJn|C26}|MTjWQdD~s!PrJbX&;|ZI z7x<4{;9mOhs|Y{0yTCWQz(-u*|G@=5H_}_7x<71{P$hp|J?=t zzg*xR<1G*ZXmWT#l%8!5>or2kB)EUV180a^1!1cZARtH?)2W1>^eb4oh1Fr9bzT<%F`>8h_aD9Jz$pP1Ti4)@}nty#i`+osK CX7S(v diff --git a/lib/model/utils/.gitignore b/lib/model/utils/.gitignore deleted file mode 100644 index 15a165d..0000000 --- a/lib/model/utils/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -*.c -*.cpp -*.so diff --git a/lib/model/utils/bbox.c b/lib/model/utils/bbox.c new file mode 100644 index 0000000..b2d780b --- /dev/null +++ b/lib/model/utils/bbox.c @@ -0,0 +1,9430 @@ +/* Generated by Cython 0.29.14 */ + +#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_14" +#define CYTHON_HEX_VERSION 0x001D0EF0 +#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 && PY_VERSION_HEX < 0x030800B2 + #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) +#else + #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) +#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__model__utils__cython_bbox +#define __PYX_HAVE_API__model__utils__cython_bbox +/* 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[] = { + "model/utils/bbox.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; + + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "model/utils/bbox.pyx":13 + * + * DTYPE = np.float + * ctypedef np.float_t DTYPE_t # <<<<<<<<<<<<<< + * + * def bbox_overlaps(np.ndarray[DTYPE_t, ndim=2] boxes, + */ +typedef __pyx_t_5numpy_float_t __pyx_t_5model_5utils_11cython_bbox_DTYPE_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 ---*/ + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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; + +/* "../../opt/conda/envs/pytorch-py3.6/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 }; + +/* 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 + +/* 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 + +/* 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 + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* BufferIndexError.proto */ +static void __Pyx_RaiseBufferIndexError(int axis); + +#define __Pyx_BufPtrStrided2d(type, buf, i0, s0, i1, s1) (type)((char*)buf + i0 * s0 + i1 * s1) +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* 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 + +/* 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, Py_ssize_t 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 + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* 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_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_int(int value); + +/* 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 *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* 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 'cython' */ + +/* 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 'model.utils.cython_bbox' */ +static PyArrayObject *__pyx_f_5model_5utils_11cython_bbox_bbox_overlaps_c(PyArrayObject *, PyArrayObject *); /*proto*/ +static PyArrayObject *__pyx_f_5model_5utils_11cython_bbox_bbox_intersections_c(PyArrayObject *, PyArrayObject *); /*proto*/ +static __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5model_5utils_11cython_bbox_DTYPE_t = { "DTYPE_t", NULL, sizeof(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t), { 0 }, 0, 'R', 0, 0 }; +#define __Pyx_MODULE_NAME "model.utils.cython_bbox" +extern int __pyx_module_is_main_model__utils__cython_bbox; +int __pyx_module_is_main_model__utils__cython_bbox = 0; + +/* Implementation of 'model.utils.cython_bbox' */ +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_np[] = "np"; +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_DTYPE[] = "DTYPE"; +static const char __pyx_k_boxes[] = "boxes"; +static const char __pyx_k_dtype[] = "dtype"; +static const char __pyx_k_float[] = "float"; +static const char __pyx_k_numpy[] = "numpy"; +static const char __pyx_k_range[] = "range"; +static const char __pyx_k_zeros[] = "zeros"; +static const char __pyx_k_import[] = "__import__"; +static const char __pyx_k_ValueError[] = "ValueError"; +static const char __pyx_k_ImportError[] = "ImportError"; +static const char __pyx_k_query_boxes[] = "query_boxes"; +static const char __pyx_k_RuntimeError[] = "RuntimeError"; +static const char __pyx_k_bbox_overlaps[] = "bbox_overlaps"; +static const char __pyx_k_bbox_intersections[] = "bbox_intersections"; +static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_model_utils_bbox_pyx[] = "model/utils/bbox.pyx"; +static const char __pyx_k_model_utils_cython_bbox[] = "model.utils.cython_bbox"; +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_n_s_DTYPE; +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_kp_u_Non_native_byte_order_not_suppor; +static PyObject *__pyx_n_s_RuntimeError; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_bbox_intersections; +static PyObject *__pyx_n_s_bbox_overlaps; +static PyObject *__pyx_n_s_boxes; +static PyObject *__pyx_n_s_cline_in_traceback; +static PyObject *__pyx_n_s_dtype; +static PyObject *__pyx_n_s_float; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_kp_s_model_utils_bbox_pyx; +static PyObject *__pyx_n_s_model_utils_cython_bbox; +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_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_query_boxes; +static PyObject *__pyx_n_s_range; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; +static PyObject *__pyx_n_s_zeros; +static PyObject *__pyx_pf_5model_5utils_11cython_bbox_bbox_overlaps(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, PyArrayObject *__pyx_v_query_boxes); /* proto */ +static PyObject *__pyx_pf_5model_5utils_11cython_bbox_2bbox_intersections(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, PyArrayObject *__pyx_v_query_boxes); /* 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_tuple_; +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__7; +static PyObject *__pyx_tuple__8; +static PyObject *__pyx_tuple__10; +static PyObject *__pyx_codeobj__9; +static PyObject *__pyx_codeobj__11; +/* Late includes */ + +/* "model/utils/bbox.pyx":15 + * ctypedef np.float_t DTYPE_t + * + * def bbox_overlaps(np.ndarray[DTYPE_t, ndim=2] boxes, # <<<<<<<<<<<<<< + * np.ndarray[DTYPE_t, ndim=2] query_boxes): + * return bbox_overlaps_c(boxes, query_boxes) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5model_5utils_11cython_bbox_1bbox_overlaps(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_5model_5utils_11cython_bbox_1bbox_overlaps = {"bbox_overlaps", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5model_5utils_11cython_bbox_1bbox_overlaps, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_5model_5utils_11cython_bbox_1bbox_overlaps(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyArrayObject *__pyx_v_boxes = 0; + PyArrayObject *__pyx_v_query_boxes = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bbox_overlaps (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_boxes,&__pyx_n_s_query_boxes,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_boxes)) != 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_query_boxes)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("bbox_overlaps", 1, 2, 2, 1); __PYX_ERR(0, 15, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "bbox_overlaps") < 0)) __PYX_ERR(0, 15, __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_boxes = ((PyArrayObject *)values[0]); + __pyx_v_query_boxes = ((PyArrayObject *)values[1]); + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("bbox_overlaps", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 15, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("model.utils.cython_bbox.bbox_overlaps", __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, 15, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_query_boxes), __pyx_ptype_5numpy_ndarray, 1, "query_boxes", 0))) __PYX_ERR(0, 16, __pyx_L1_error) + __pyx_r = __pyx_pf_5model_5utils_11cython_bbox_bbox_overlaps(__pyx_self, __pyx_v_boxes, __pyx_v_query_boxes); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5model_5utils_11cython_bbox_bbox_overlaps(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, PyArrayObject *__pyx_v_query_boxes) { + __Pyx_LocalBuf_ND __pyx_pybuffernd_boxes; + __Pyx_Buffer __pyx_pybuffer_boxes; + __Pyx_LocalBuf_ND __pyx_pybuffernd_query_boxes; + __Pyx_Buffer __pyx_pybuffer_query_boxes; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("bbox_overlaps", 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_pybuffer_query_boxes.pybuffer.buf = NULL; + __pyx_pybuffer_query_boxes.refcount = 0; + __pyx_pybuffernd_query_boxes.data = NULL; + __pyx_pybuffernd_query_boxes.rcbuffer = &__pyx_pybuffer_query_boxes; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_boxes, &__Pyx_TypeInfo_nn___pyx_t_5model_5utils_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 15, __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]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_query_boxes, &__Pyx_TypeInfo_nn___pyx_t_5model_5utils_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 15, __pyx_L1_error) + } + __pyx_pybuffernd_query_boxes.diminfo[0].strides = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_query_boxes.diminfo[0].shape = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_query_boxes.diminfo[1].strides = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_query_boxes.diminfo[1].shape = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.shape[1]; + + /* "model/utils/bbox.pyx":17 + * def bbox_overlaps(np.ndarray[DTYPE_t, ndim=2] boxes, + * np.ndarray[DTYPE_t, ndim=2] query_boxes): + * return bbox_overlaps_c(boxes, query_boxes) # <<<<<<<<<<<<<< + * + * cdef np.ndarray[DTYPE_t, ndim=2] bbox_overlaps_c( + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_5model_5utils_11cython_bbox_bbox_overlaps_c(((PyArrayObject *)__pyx_v_boxes), ((PyArrayObject *)__pyx_v_query_boxes))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "model/utils/bbox.pyx":15 + * ctypedef np.float_t DTYPE_t + * + * def bbox_overlaps(np.ndarray[DTYPE_t, ndim=2] boxes, # <<<<<<<<<<<<<< + * np.ndarray[DTYPE_t, ndim=2] query_boxes): + * return bbox_overlaps_c(boxes, query_boxes) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + { 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_SafeReleaseBuffer(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("model.utils.cython_bbox.bbox_overlaps", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "model/utils/bbox.pyx":19 + * return bbox_overlaps_c(boxes, query_boxes) + * + * cdef np.ndarray[DTYPE_t, ndim=2] bbox_overlaps_c( # <<<<<<<<<<<<<< + * np.ndarray[DTYPE_t, ndim=2] boxes, + * np.ndarray[DTYPE_t, ndim=2] query_boxes): + */ + +static PyArrayObject *__pyx_f_5model_5utils_11cython_bbox_bbox_overlaps_c(PyArrayObject *__pyx_v_boxes, PyArrayObject *__pyx_v_query_boxes) { + unsigned int __pyx_v_N; + unsigned int __pyx_v_K; + PyArrayObject *__pyx_v_overlaps = 0; + __pyx_t_5model_5utils_11cython_bbox_DTYPE_t __pyx_v_iw; + __pyx_t_5model_5utils_11cython_bbox_DTYPE_t __pyx_v_ih; + __pyx_t_5model_5utils_11cython_bbox_DTYPE_t __pyx_v_box_area; + __pyx_t_5model_5utils_11cython_bbox_DTYPE_t __pyx_v_ua; + unsigned int __pyx_v_k; + unsigned int __pyx_v_n; + __Pyx_LocalBuf_ND __pyx_pybuffernd_boxes; + __Pyx_Buffer __pyx_pybuffer_boxes; + __Pyx_LocalBuf_ND __pyx_pybuffernd_overlaps; + __Pyx_Buffer __pyx_pybuffer_overlaps; + __Pyx_LocalBuf_ND __pyx_pybuffernd_query_boxes; + __Pyx_Buffer __pyx_pybuffer_query_boxes; + PyArrayObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyArrayObject *__pyx_t_5 = NULL; + unsigned int __pyx_t_6; + unsigned int __pyx_t_7; + unsigned int __pyx_t_8; + size_t __pyx_t_9; + Py_ssize_t __pyx_t_10; + int __pyx_t_11; + size_t __pyx_t_12; + Py_ssize_t __pyx_t_13; + size_t __pyx_t_14; + Py_ssize_t __pyx_t_15; + size_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + unsigned int __pyx_t_18; + unsigned int __pyx_t_19; + unsigned int __pyx_t_20; + size_t __pyx_t_21; + Py_ssize_t __pyx_t_22; + __pyx_t_5model_5utils_11cython_bbox_DTYPE_t __pyx_t_23; + size_t __pyx_t_24; + Py_ssize_t __pyx_t_25; + __pyx_t_5model_5utils_11cython_bbox_DTYPE_t __pyx_t_26; + __pyx_t_5model_5utils_11cython_bbox_DTYPE_t __pyx_t_27; + size_t __pyx_t_28; + Py_ssize_t __pyx_t_29; + size_t __pyx_t_30; + Py_ssize_t __pyx_t_31; + __pyx_t_5model_5utils_11cython_bbox_DTYPE_t __pyx_t_32; + int __pyx_t_33; + size_t __pyx_t_34; + Py_ssize_t __pyx_t_35; + size_t __pyx_t_36; + Py_ssize_t __pyx_t_37; + size_t __pyx_t_38; + Py_ssize_t __pyx_t_39; + size_t __pyx_t_40; + Py_ssize_t __pyx_t_41; + size_t __pyx_t_42; + Py_ssize_t __pyx_t_43; + size_t __pyx_t_44; + Py_ssize_t __pyx_t_45; + size_t __pyx_t_46; + Py_ssize_t __pyx_t_47; + size_t __pyx_t_48; + Py_ssize_t __pyx_t_49; + size_t __pyx_t_50; + size_t __pyx_t_51; + __Pyx_RefNannySetupContext("bbox_overlaps_c", 0); + __pyx_pybuffer_overlaps.pybuffer.buf = NULL; + __pyx_pybuffer_overlaps.refcount = 0; + __pyx_pybuffernd_overlaps.data = NULL; + __pyx_pybuffernd_overlaps.rcbuffer = &__pyx_pybuffer_overlaps; + __pyx_pybuffer_boxes.pybuffer.buf = NULL; + __pyx_pybuffer_boxes.refcount = 0; + __pyx_pybuffernd_boxes.data = NULL; + __pyx_pybuffernd_boxes.rcbuffer = &__pyx_pybuffer_boxes; + __pyx_pybuffer_query_boxes.pybuffer.buf = NULL; + __pyx_pybuffer_query_boxes.refcount = 0; + __pyx_pybuffernd_query_boxes.data = NULL; + __pyx_pybuffernd_query_boxes.rcbuffer = &__pyx_pybuffer_query_boxes; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_boxes, &__Pyx_TypeInfo_nn___pyx_t_5model_5utils_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 19, __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]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_query_boxes, &__Pyx_TypeInfo_nn___pyx_t_5model_5utils_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 19, __pyx_L1_error) + } + __pyx_pybuffernd_query_boxes.diminfo[0].strides = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_query_boxes.diminfo[0].shape = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_query_boxes.diminfo[1].strides = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_query_boxes.diminfo[1].shape = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.shape[1]; + + /* "model/utils/bbox.pyx":31 + * overlaps: (N, K) ndarray of overlap between boxes and query_boxes + * """ + * cdef unsigned int N = boxes.shape[0] # <<<<<<<<<<<<<< + * cdef unsigned int K = query_boxes.shape[0] + * cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE) + */ + __pyx_v_N = (__pyx_v_boxes->dimensions[0]); + + /* "model/utils/bbox.pyx":32 + * """ + * cdef unsigned int N = boxes.shape[0] + * cdef unsigned int K = query_boxes.shape[0] # <<<<<<<<<<<<<< + * cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE) + * cdef DTYPE_t iw, ih, box_area + */ + __pyx_v_K = (__pyx_v_query_boxes->dimensions[0]); + + /* "model/utils/bbox.pyx":33 + * cdef unsigned int N = boxes.shape[0] + * cdef unsigned int K = query_boxes.shape[0] + * cdef np.ndarray[DTYPE_t, ndim=2] overlaps = np.zeros((N, K), dtype=DTYPE) # <<<<<<<<<<<<<< + * cdef DTYPE_t iw, ih, box_area + * cdef DTYPE_t ua + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_N); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_K); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); + __pyx_t_1 = 0; + __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 33, __pyx_L1_error) + __pyx_t_5 = ((PyArrayObject *)__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_overlaps.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_5model_5utils_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) { + __pyx_v_overlaps = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 33, __pyx_L1_error) + } else {__pyx_pybuffernd_overlaps.diminfo[0].strides = __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_overlaps.diminfo[0].shape = __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_overlaps.diminfo[1].strides = __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_overlaps.diminfo[1].shape = __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.shape[1]; + } + } + __pyx_t_5 = 0; + __pyx_v_overlaps = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "model/utils/bbox.pyx":37 + * cdef DTYPE_t ua + * cdef unsigned int k, n + * for k in range(K): # <<<<<<<<<<<<<< + * box_area = ( + * (query_boxes[k, 2] - query_boxes[k, 0] + 1) * + */ + __pyx_t_6 = __pyx_v_K; + __pyx_t_7 = __pyx_t_6; + for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { + __pyx_v_k = __pyx_t_8; + + /* "model/utils/bbox.pyx":39 + * for k in range(K): + * box_area = ( + * (query_boxes[k, 2] - query_boxes[k, 0] + 1) * # <<<<<<<<<<<<<< + * (query_boxes[k, 3] - query_boxes[k, 1] + 1) + * ) + */ + __pyx_t_9 = __pyx_v_k; + __pyx_t_10 = 2; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_9 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_10 < 0) { + __pyx_t_10 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_10 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_10 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 39, __pyx_L1_error) + } + __pyx_t_12 = __pyx_v_k; + __pyx_t_13 = 0; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_12 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_13 < 0) { + __pyx_t_13 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_13 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_13 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 39, __pyx_L1_error) + } + + /* "model/utils/bbox.pyx":40 + * box_area = ( + * (query_boxes[k, 2] - query_boxes[k, 0] + 1) * + * (query_boxes[k, 3] - query_boxes[k, 1] + 1) # <<<<<<<<<<<<<< + * ) + * for n in range(N): + */ + __pyx_t_14 = __pyx_v_k; + __pyx_t_15 = 3; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_14 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_15 < 0) { + __pyx_t_15 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_15 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_15 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 40, __pyx_L1_error) + } + __pyx_t_16 = __pyx_v_k; + __pyx_t_17 = 1; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 40, __pyx_L1_error) + } + + /* "model/utils/bbox.pyx":39 + * for k in range(K): + * box_area = ( + * (query_boxes[k, 2] - query_boxes[k, 0] + 1) * # <<<<<<<<<<<<<< + * (query_boxes[k, 3] - query_boxes[k, 1] + 1) + * ) + */ + __pyx_v_box_area = ((((*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_9, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_10, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_12, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_13, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) + 1.0) * (((*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_15, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) + 1.0)); + + /* "model/utils/bbox.pyx":42 + * (query_boxes[k, 3] - query_boxes[k, 1] + 1) + * ) + * for n in range(N): # <<<<<<<<<<<<<< + * iw = ( + * min(boxes[n, 2], query_boxes[k, 2]) - + */ + __pyx_t_18 = __pyx_v_N; + __pyx_t_19 = __pyx_t_18; + for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) { + __pyx_v_n = __pyx_t_20; + + /* "model/utils/bbox.pyx":44 + * for n in range(N): + * iw = ( + * min(boxes[n, 2], query_boxes[k, 2]) - # <<<<<<<<<<<<<< + * max(boxes[n, 0], query_boxes[k, 0]) + 1 + * ) + */ + __pyx_t_21 = __pyx_v_k; + __pyx_t_22 = 2; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_21 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_22 < 0) { + __pyx_t_22 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_22 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_22 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 44, __pyx_L1_error) + } + __pyx_t_23 = (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_21, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_22, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); + __pyx_t_24 = __pyx_v_n; + __pyx_t_25 = 2; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_24 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_25 < 0) { + __pyx_t_25 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_25 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_25 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 44, __pyx_L1_error) + } + __pyx_t_26 = (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_24, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_25, __pyx_pybuffernd_boxes.diminfo[1].strides)); + if (((__pyx_t_23 < __pyx_t_26) != 0)) { + __pyx_t_27 = __pyx_t_23; + } else { + __pyx_t_27 = __pyx_t_26; + } + + /* "model/utils/bbox.pyx":45 + * iw = ( + * min(boxes[n, 2], query_boxes[k, 2]) - + * max(boxes[n, 0], query_boxes[k, 0]) + 1 # <<<<<<<<<<<<<< + * ) + * if iw > 0: + */ + __pyx_t_28 = __pyx_v_k; + __pyx_t_29 = 0; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_28 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_29 < 0) { + __pyx_t_29 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_29 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_29 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 45, __pyx_L1_error) + } + __pyx_t_23 = (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_28, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_29, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); + __pyx_t_30 = __pyx_v_n; + __pyx_t_31 = 0; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_30 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_31 < 0) { + __pyx_t_31 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_31 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_31 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 45, __pyx_L1_error) + } + __pyx_t_26 = (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_30, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_31, __pyx_pybuffernd_boxes.diminfo[1].strides)); + if (((__pyx_t_23 > __pyx_t_26) != 0)) { + __pyx_t_32 = __pyx_t_23; + } else { + __pyx_t_32 = __pyx_t_26; + } + + /* "model/utils/bbox.pyx":44 + * for n in range(N): + * iw = ( + * min(boxes[n, 2], query_boxes[k, 2]) - # <<<<<<<<<<<<<< + * max(boxes[n, 0], query_boxes[k, 0]) + 1 + * ) + */ + __pyx_v_iw = ((__pyx_t_27 - __pyx_t_32) + 1.0); + + /* "model/utils/bbox.pyx":47 + * max(boxes[n, 0], query_boxes[k, 0]) + 1 + * ) + * if iw > 0: # <<<<<<<<<<<<<< + * ih = ( + * min(boxes[n, 3], query_boxes[k, 3]) - + */ + __pyx_t_33 = ((__pyx_v_iw > 0.0) != 0); + if (__pyx_t_33) { + + /* "model/utils/bbox.pyx":49 + * if iw > 0: + * ih = ( + * min(boxes[n, 3], query_boxes[k, 3]) - # <<<<<<<<<<<<<< + * max(boxes[n, 1], query_boxes[k, 1]) + 1 + * ) + */ + __pyx_t_34 = __pyx_v_k; + __pyx_t_35 = 3; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_34 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_35 < 0) { + __pyx_t_35 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_35 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_35 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 49, __pyx_L1_error) + } + __pyx_t_32 = (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_34, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_35, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); + __pyx_t_36 = __pyx_v_n; + __pyx_t_37 = 3; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_36 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_37 < 0) { + __pyx_t_37 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_37 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_37 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 49, __pyx_L1_error) + } + __pyx_t_27 = (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_36, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_37, __pyx_pybuffernd_boxes.diminfo[1].strides)); + if (((__pyx_t_32 < __pyx_t_27) != 0)) { + __pyx_t_23 = __pyx_t_32; + } else { + __pyx_t_23 = __pyx_t_27; + } + + /* "model/utils/bbox.pyx":50 + * ih = ( + * min(boxes[n, 3], query_boxes[k, 3]) - + * max(boxes[n, 1], query_boxes[k, 1]) + 1 # <<<<<<<<<<<<<< + * ) + * if ih > 0: + */ + __pyx_t_38 = __pyx_v_k; + __pyx_t_39 = 1; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_38 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_39 < 0) { + __pyx_t_39 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_39 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_39 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 50, __pyx_L1_error) + } + __pyx_t_32 = (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_38, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_39, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); + __pyx_t_40 = __pyx_v_n; + __pyx_t_41 = 1; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_40 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_41 < 0) { + __pyx_t_41 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_41 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_41 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 50, __pyx_L1_error) + } + __pyx_t_27 = (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_40, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_41, __pyx_pybuffernd_boxes.diminfo[1].strides)); + if (((__pyx_t_32 > __pyx_t_27) != 0)) { + __pyx_t_26 = __pyx_t_32; + } else { + __pyx_t_26 = __pyx_t_27; + } + + /* "model/utils/bbox.pyx":49 + * if iw > 0: + * ih = ( + * min(boxes[n, 3], query_boxes[k, 3]) - # <<<<<<<<<<<<<< + * max(boxes[n, 1], query_boxes[k, 1]) + 1 + * ) + */ + __pyx_v_ih = ((__pyx_t_23 - __pyx_t_26) + 1.0); + + /* "model/utils/bbox.pyx":52 + * max(boxes[n, 1], query_boxes[k, 1]) + 1 + * ) + * if ih > 0: # <<<<<<<<<<<<<< + * ua = float( + * (boxes[n, 2] - boxes[n, 0] + 1) * + */ + __pyx_t_33 = ((__pyx_v_ih > 0.0) != 0); + if (__pyx_t_33) { + + /* "model/utils/bbox.pyx":54 + * if ih > 0: + * ua = float( + * (boxes[n, 2] - boxes[n, 0] + 1) * # <<<<<<<<<<<<<< + * (boxes[n, 3] - boxes[n, 1] + 1) + + * box_area - iw * ih + */ + __pyx_t_42 = __pyx_v_n; + __pyx_t_43 = 2; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_42 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_43 < 0) { + __pyx_t_43 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_43 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_43 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 54, __pyx_L1_error) + } + __pyx_t_44 = __pyx_v_n; + __pyx_t_45 = 0; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_44 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_45 < 0) { + __pyx_t_45 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_45 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_45 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 54, __pyx_L1_error) + } + + /* "model/utils/bbox.pyx":55 + * ua = float( + * (boxes[n, 2] - boxes[n, 0] + 1) * + * (boxes[n, 3] - boxes[n, 1] + 1) + # <<<<<<<<<<<<<< + * box_area - iw * ih + * ) + */ + __pyx_t_46 = __pyx_v_n; + __pyx_t_47 = 3; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_46 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_47 < 0) { + __pyx_t_47 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_47 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_47 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 55, __pyx_L1_error) + } + __pyx_t_48 = __pyx_v_n; + __pyx_t_49 = 1; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_48 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_49 < 0) { + __pyx_t_49 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_49 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_49 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 55, __pyx_L1_error) + } + + /* "model/utils/bbox.pyx":53 + * ) + * if ih > 0: + * ua = float( # <<<<<<<<<<<<<< + * (boxes[n, 2] - boxes[n, 0] + 1) * + * (boxes[n, 3] - boxes[n, 1] + 1) + + */ + __pyx_v_ua = ((double)((((((*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_42, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_43, __pyx_pybuffernd_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_44, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_45, __pyx_pybuffernd_boxes.diminfo[1].strides))) + 1.0) * (((*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_46, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_47, __pyx_pybuffernd_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_48, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_49, __pyx_pybuffernd_boxes.diminfo[1].strides))) + 1.0)) + __pyx_v_box_area) - (__pyx_v_iw * __pyx_v_ih))); + + /* "model/utils/bbox.pyx":58 + * box_area - iw * ih + * ) + * overlaps[n, k] = iw * ih / ua # <<<<<<<<<<<<<< + * return overlaps + * + */ + __pyx_t_26 = (__pyx_v_iw * __pyx_v_ih); + if (unlikely(__pyx_v_ua == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "float division"); + __PYX_ERR(0, 58, __pyx_L1_error) + } + __pyx_t_50 = __pyx_v_n; + __pyx_t_51 = __pyx_v_k; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_50 >= (size_t)__pyx_pybuffernd_overlaps.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_51 >= (size_t)__pyx_pybuffernd_overlaps.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 58, __pyx_L1_error) + } + *__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_overlaps.rcbuffer->pybuffer.buf, __pyx_t_50, __pyx_pybuffernd_overlaps.diminfo[0].strides, __pyx_t_51, __pyx_pybuffernd_overlaps.diminfo[1].strides) = (__pyx_t_26 / __pyx_v_ua); + + /* "model/utils/bbox.pyx":52 + * max(boxes[n, 1], query_boxes[k, 1]) + 1 + * ) + * if ih > 0: # <<<<<<<<<<<<<< + * ua = float( + * (boxes[n, 2] - boxes[n, 0] + 1) * + */ + } + + /* "model/utils/bbox.pyx":47 + * max(boxes[n, 0], query_boxes[k, 0]) + 1 + * ) + * if iw > 0: # <<<<<<<<<<<<<< + * ih = ( + * min(boxes[n, 3], query_boxes[k, 3]) - + */ + } + } + } + + /* "model/utils/bbox.pyx":59 + * ) + * overlaps[n, k] = iw * ih / ua + * return overlaps # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_overlaps)); + __pyx_r = ((PyArrayObject *)__pyx_v_overlaps); + goto __pyx_L0; + + /* "model/utils/bbox.pyx":19 + * return bbox_overlaps_c(boxes, query_boxes) + * + * cdef np.ndarray[DTYPE_t, ndim=2] bbox_overlaps_c( # <<<<<<<<<<<<<< + * np.ndarray[DTYPE_t, ndim=2] boxes, + * np.ndarray[DTYPE_t, ndim=2] query_boxes): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + { 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_SafeReleaseBuffer(&__pyx_pybuffernd_overlaps.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("model.utils.cython_bbox.bbox_overlaps_c", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_overlaps.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_overlaps); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "model/utils/bbox.pyx":62 + * + * + * def bbox_intersections( # <<<<<<<<<<<<<< + * np.ndarray[DTYPE_t, ndim=2] boxes, + * np.ndarray[DTYPE_t, ndim=2] query_boxes): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5model_5utils_11cython_bbox_3bbox_intersections(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_5model_5utils_11cython_bbox_3bbox_intersections = {"bbox_intersections", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_5model_5utils_11cython_bbox_3bbox_intersections, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_5model_5utils_11cython_bbox_3bbox_intersections(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyArrayObject *__pyx_v_boxes = 0; + PyArrayObject *__pyx_v_query_boxes = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("bbox_intersections (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_boxes,&__pyx_n_s_query_boxes,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_boxes)) != 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_query_boxes)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("bbox_intersections", 1, 2, 2, 1); __PYX_ERR(0, 62, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "bbox_intersections") < 0)) __PYX_ERR(0, 62, __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_boxes = ((PyArrayObject *)values[0]); + __pyx_v_query_boxes = ((PyArrayObject *)values[1]); + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("bbox_intersections", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 62, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("model.utils.cython_bbox.bbox_intersections", __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, 63, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_query_boxes), __pyx_ptype_5numpy_ndarray, 1, "query_boxes", 0))) __PYX_ERR(0, 64, __pyx_L1_error) + __pyx_r = __pyx_pf_5model_5utils_11cython_bbox_2bbox_intersections(__pyx_self, __pyx_v_boxes, __pyx_v_query_boxes); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5model_5utils_11cython_bbox_2bbox_intersections(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_boxes, PyArrayObject *__pyx_v_query_boxes) { + __Pyx_LocalBuf_ND __pyx_pybuffernd_boxes; + __Pyx_Buffer __pyx_pybuffer_boxes; + __Pyx_LocalBuf_ND __pyx_pybuffernd_query_boxes; + __Pyx_Buffer __pyx_pybuffer_query_boxes; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("bbox_intersections", 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_pybuffer_query_boxes.pybuffer.buf = NULL; + __pyx_pybuffer_query_boxes.refcount = 0; + __pyx_pybuffernd_query_boxes.data = NULL; + __pyx_pybuffernd_query_boxes.rcbuffer = &__pyx_pybuffer_query_boxes; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_boxes, &__Pyx_TypeInfo_nn___pyx_t_5model_5utils_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 62, __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]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_query_boxes, &__Pyx_TypeInfo_nn___pyx_t_5model_5utils_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 62, __pyx_L1_error) + } + __pyx_pybuffernd_query_boxes.diminfo[0].strides = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_query_boxes.diminfo[0].shape = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_query_boxes.diminfo[1].strides = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_query_boxes.diminfo[1].shape = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.shape[1]; + + /* "model/utils/bbox.pyx":65 + * np.ndarray[DTYPE_t, ndim=2] boxes, + * np.ndarray[DTYPE_t, ndim=2] query_boxes): + * return bbox_intersections_c(boxes, query_boxes) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((PyObject *)__pyx_f_5model_5utils_11cython_bbox_bbox_intersections_c(((PyArrayObject *)__pyx_v_boxes), ((PyArrayObject *)__pyx_v_query_boxes))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "model/utils/bbox.pyx":62 + * + * + * def bbox_intersections( # <<<<<<<<<<<<<< + * np.ndarray[DTYPE_t, ndim=2] boxes, + * np.ndarray[DTYPE_t, ndim=2] query_boxes): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + { 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_SafeReleaseBuffer(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("model.utils.cython_bbox.bbox_intersections", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "model/utils/bbox.pyx":68 + * + * + * cdef np.ndarray[DTYPE_t, ndim=2] bbox_intersections_c( # <<<<<<<<<<<<<< + * np.ndarray[DTYPE_t, ndim=2] boxes, + * np.ndarray[DTYPE_t, ndim=2] query_boxes): + */ + +static PyArrayObject *__pyx_f_5model_5utils_11cython_bbox_bbox_intersections_c(PyArrayObject *__pyx_v_boxes, PyArrayObject *__pyx_v_query_boxes) { + unsigned int __pyx_v_N; + unsigned int __pyx_v_K; + PyArrayObject *__pyx_v_intersec = 0; + __pyx_t_5model_5utils_11cython_bbox_DTYPE_t __pyx_v_iw; + __pyx_t_5model_5utils_11cython_bbox_DTYPE_t __pyx_v_ih; + __pyx_t_5model_5utils_11cython_bbox_DTYPE_t __pyx_v_box_area; + unsigned int __pyx_v_k; + unsigned int __pyx_v_n; + __Pyx_LocalBuf_ND __pyx_pybuffernd_boxes; + __Pyx_Buffer __pyx_pybuffer_boxes; + __Pyx_LocalBuf_ND __pyx_pybuffernd_intersec; + __Pyx_Buffer __pyx_pybuffer_intersec; + __Pyx_LocalBuf_ND __pyx_pybuffernd_query_boxes; + __Pyx_Buffer __pyx_pybuffer_query_boxes; + PyArrayObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyArrayObject *__pyx_t_5 = NULL; + unsigned int __pyx_t_6; + unsigned int __pyx_t_7; + unsigned int __pyx_t_8; + size_t __pyx_t_9; + Py_ssize_t __pyx_t_10; + int __pyx_t_11; + size_t __pyx_t_12; + Py_ssize_t __pyx_t_13; + size_t __pyx_t_14; + Py_ssize_t __pyx_t_15; + size_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + unsigned int __pyx_t_18; + unsigned int __pyx_t_19; + unsigned int __pyx_t_20; + size_t __pyx_t_21; + Py_ssize_t __pyx_t_22; + __pyx_t_5model_5utils_11cython_bbox_DTYPE_t __pyx_t_23; + size_t __pyx_t_24; + Py_ssize_t __pyx_t_25; + __pyx_t_5model_5utils_11cython_bbox_DTYPE_t __pyx_t_26; + __pyx_t_5model_5utils_11cython_bbox_DTYPE_t __pyx_t_27; + size_t __pyx_t_28; + Py_ssize_t __pyx_t_29; + size_t __pyx_t_30; + Py_ssize_t __pyx_t_31; + __pyx_t_5model_5utils_11cython_bbox_DTYPE_t __pyx_t_32; + int __pyx_t_33; + size_t __pyx_t_34; + Py_ssize_t __pyx_t_35; + size_t __pyx_t_36; + Py_ssize_t __pyx_t_37; + size_t __pyx_t_38; + Py_ssize_t __pyx_t_39; + size_t __pyx_t_40; + Py_ssize_t __pyx_t_41; + size_t __pyx_t_42; + size_t __pyx_t_43; + __Pyx_RefNannySetupContext("bbox_intersections_c", 0); + __pyx_pybuffer_intersec.pybuffer.buf = NULL; + __pyx_pybuffer_intersec.refcount = 0; + __pyx_pybuffernd_intersec.data = NULL; + __pyx_pybuffernd_intersec.rcbuffer = &__pyx_pybuffer_intersec; + __pyx_pybuffer_boxes.pybuffer.buf = NULL; + __pyx_pybuffer_boxes.refcount = 0; + __pyx_pybuffernd_boxes.data = NULL; + __pyx_pybuffernd_boxes.rcbuffer = &__pyx_pybuffer_boxes; + __pyx_pybuffer_query_boxes.pybuffer.buf = NULL; + __pyx_pybuffer_query_boxes.refcount = 0; + __pyx_pybuffernd_query_boxes.data = NULL; + __pyx_pybuffernd_query_boxes.rcbuffer = &__pyx_pybuffer_query_boxes; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_boxes, &__Pyx_TypeInfo_nn___pyx_t_5model_5utils_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 68, __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]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer, (PyObject*)__pyx_v_query_boxes, &__Pyx_TypeInfo_nn___pyx_t_5model_5utils_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 68, __pyx_L1_error) + } + __pyx_pybuffernd_query_boxes.diminfo[0].strides = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_query_boxes.diminfo[0].shape = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_query_boxes.diminfo[1].strides = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_query_boxes.diminfo[1].shape = __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.shape[1]; + + /* "model/utils/bbox.pyx":82 + * overlaps: (N, K) ndarray of intersec between boxes and query_boxes + * """ + * cdef unsigned int N = boxes.shape[0] # <<<<<<<<<<<<<< + * cdef unsigned int K = query_boxes.shape[0] + * cdef np.ndarray[DTYPE_t, ndim=2] intersec = np.zeros((N, K), dtype=DTYPE) + */ + __pyx_v_N = (__pyx_v_boxes->dimensions[0]); + + /* "model/utils/bbox.pyx":83 + * """ + * cdef unsigned int N = boxes.shape[0] + * cdef unsigned int K = query_boxes.shape[0] # <<<<<<<<<<<<<< + * cdef np.ndarray[DTYPE_t, ndim=2] intersec = np.zeros((N, K), dtype=DTYPE) + * cdef DTYPE_t iw, ih, box_area + */ + __pyx_v_K = (__pyx_v_query_boxes->dimensions[0]); + + /* "model/utils/bbox.pyx":84 + * cdef unsigned int N = boxes.shape[0] + * cdef unsigned int K = query_boxes.shape[0] + * cdef np.ndarray[DTYPE_t, ndim=2] intersec = np.zeros((N, K), dtype=DTYPE) # <<<<<<<<<<<<<< + * cdef DTYPE_t iw, ih, box_area + * cdef DTYPE_t ua + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_zeros); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_N); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyInt_From_unsigned_int(__pyx_v_K); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); + __pyx_t_1 = 0; + __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_dtype, __pyx_t_1) < 0) __PYX_ERR(0, 84, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 84, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 84, __pyx_L1_error) + __pyx_t_5 = ((PyArrayObject *)__pyx_t_1); + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_intersec.rcbuffer->pybuffer, (PyObject*)__pyx_t_5, &__Pyx_TypeInfo_nn___pyx_t_5model_5utils_11cython_bbox_DTYPE_t, PyBUF_FORMAT| PyBUF_STRIDES| PyBUF_WRITABLE, 2, 0, __pyx_stack) == -1)) { + __pyx_v_intersec = ((PyArrayObject *)Py_None); __Pyx_INCREF(Py_None); __pyx_pybuffernd_intersec.rcbuffer->pybuffer.buf = NULL; + __PYX_ERR(0, 84, __pyx_L1_error) + } else {__pyx_pybuffernd_intersec.diminfo[0].strides = __pyx_pybuffernd_intersec.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_intersec.diminfo[0].shape = __pyx_pybuffernd_intersec.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_intersec.diminfo[1].strides = __pyx_pybuffernd_intersec.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_intersec.diminfo[1].shape = __pyx_pybuffernd_intersec.rcbuffer->pybuffer.shape[1]; + } + } + __pyx_t_5 = 0; + __pyx_v_intersec = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "model/utils/bbox.pyx":88 + * cdef DTYPE_t ua + * cdef unsigned int k, n + * for k in range(K): # <<<<<<<<<<<<<< + * box_area = ( + * (query_boxes[k, 2] - query_boxes[k, 0] + 1) * + */ + __pyx_t_6 = __pyx_v_K; + __pyx_t_7 = __pyx_t_6; + for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { + __pyx_v_k = __pyx_t_8; + + /* "model/utils/bbox.pyx":90 + * for k in range(K): + * box_area = ( + * (query_boxes[k, 2] - query_boxes[k, 0] + 1) * # <<<<<<<<<<<<<< + * (query_boxes[k, 3] - query_boxes[k, 1] + 1) + * ) + */ + __pyx_t_9 = __pyx_v_k; + __pyx_t_10 = 2; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_9 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_10 < 0) { + __pyx_t_10 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_10 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_10 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 90, __pyx_L1_error) + } + __pyx_t_12 = __pyx_v_k; + __pyx_t_13 = 0; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_12 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_13 < 0) { + __pyx_t_13 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_13 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_13 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 90, __pyx_L1_error) + } + + /* "model/utils/bbox.pyx":91 + * box_area = ( + * (query_boxes[k, 2] - query_boxes[k, 0] + 1) * + * (query_boxes[k, 3] - query_boxes[k, 1] + 1) # <<<<<<<<<<<<<< + * ) + * for n in range(N): + */ + __pyx_t_14 = __pyx_v_k; + __pyx_t_15 = 3; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_14 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_15 < 0) { + __pyx_t_15 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_15 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_15 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 91, __pyx_L1_error) + } + __pyx_t_16 = __pyx_v_k; + __pyx_t_17 = 1; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_16 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_17 < 0) { + __pyx_t_17 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_17 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_17 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 91, __pyx_L1_error) + } + + /* "model/utils/bbox.pyx":90 + * for k in range(K): + * box_area = ( + * (query_boxes[k, 2] - query_boxes[k, 0] + 1) * # <<<<<<<<<<<<<< + * (query_boxes[k, 3] - query_boxes[k, 1] + 1) + * ) + */ + __pyx_v_box_area = ((((*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_9, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_10, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_12, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_13, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) + 1.0) * (((*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_14, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_15, __pyx_pybuffernd_query_boxes.diminfo[1].strides)) - (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_16, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_17, __pyx_pybuffernd_query_boxes.diminfo[1].strides))) + 1.0)); + + /* "model/utils/bbox.pyx":93 + * (query_boxes[k, 3] - query_boxes[k, 1] + 1) + * ) + * for n in range(N): # <<<<<<<<<<<<<< + * iw = ( + * min(boxes[n, 2], query_boxes[k, 2]) - + */ + __pyx_t_18 = __pyx_v_N; + __pyx_t_19 = __pyx_t_18; + for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) { + __pyx_v_n = __pyx_t_20; + + /* "model/utils/bbox.pyx":95 + * for n in range(N): + * iw = ( + * min(boxes[n, 2], query_boxes[k, 2]) - # <<<<<<<<<<<<<< + * max(boxes[n, 0], query_boxes[k, 0]) + 1 + * ) + */ + __pyx_t_21 = __pyx_v_k; + __pyx_t_22 = 2; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_21 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_22 < 0) { + __pyx_t_22 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_22 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_22 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 95, __pyx_L1_error) + } + __pyx_t_23 = (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_21, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_22, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); + __pyx_t_24 = __pyx_v_n; + __pyx_t_25 = 2; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_24 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_25 < 0) { + __pyx_t_25 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_25 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_25 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 95, __pyx_L1_error) + } + __pyx_t_26 = (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_24, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_25, __pyx_pybuffernd_boxes.diminfo[1].strides)); + if (((__pyx_t_23 < __pyx_t_26) != 0)) { + __pyx_t_27 = __pyx_t_23; + } else { + __pyx_t_27 = __pyx_t_26; + } + + /* "model/utils/bbox.pyx":96 + * iw = ( + * min(boxes[n, 2], query_boxes[k, 2]) - + * max(boxes[n, 0], query_boxes[k, 0]) + 1 # <<<<<<<<<<<<<< + * ) + * if iw > 0: + */ + __pyx_t_28 = __pyx_v_k; + __pyx_t_29 = 0; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_28 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_29 < 0) { + __pyx_t_29 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_29 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_29 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 96, __pyx_L1_error) + } + __pyx_t_23 = (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_28, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_29, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); + __pyx_t_30 = __pyx_v_n; + __pyx_t_31 = 0; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_30 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_31 < 0) { + __pyx_t_31 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_31 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_31 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 96, __pyx_L1_error) + } + __pyx_t_26 = (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_30, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_31, __pyx_pybuffernd_boxes.diminfo[1].strides)); + if (((__pyx_t_23 > __pyx_t_26) != 0)) { + __pyx_t_32 = __pyx_t_23; + } else { + __pyx_t_32 = __pyx_t_26; + } + + /* "model/utils/bbox.pyx":95 + * for n in range(N): + * iw = ( + * min(boxes[n, 2], query_boxes[k, 2]) - # <<<<<<<<<<<<<< + * max(boxes[n, 0], query_boxes[k, 0]) + 1 + * ) + */ + __pyx_v_iw = ((__pyx_t_27 - __pyx_t_32) + 1.0); + + /* "model/utils/bbox.pyx":98 + * max(boxes[n, 0], query_boxes[k, 0]) + 1 + * ) + * if iw > 0: # <<<<<<<<<<<<<< + * ih = ( + * min(boxes[n, 3], query_boxes[k, 3]) - + */ + __pyx_t_33 = ((__pyx_v_iw > 0.0) != 0); + if (__pyx_t_33) { + + /* "model/utils/bbox.pyx":100 + * if iw > 0: + * ih = ( + * min(boxes[n, 3], query_boxes[k, 3]) - # <<<<<<<<<<<<<< + * max(boxes[n, 1], query_boxes[k, 1]) + 1 + * ) + */ + __pyx_t_34 = __pyx_v_k; + __pyx_t_35 = 3; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_34 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_35 < 0) { + __pyx_t_35 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_35 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_35 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 100, __pyx_L1_error) + } + __pyx_t_32 = (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_34, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_35, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); + __pyx_t_36 = __pyx_v_n; + __pyx_t_37 = 3; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_36 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_37 < 0) { + __pyx_t_37 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_37 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_37 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 100, __pyx_L1_error) + } + __pyx_t_27 = (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_36, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_37, __pyx_pybuffernd_boxes.diminfo[1].strides)); + if (((__pyx_t_32 < __pyx_t_27) != 0)) { + __pyx_t_23 = __pyx_t_32; + } else { + __pyx_t_23 = __pyx_t_27; + } + + /* "model/utils/bbox.pyx":101 + * ih = ( + * min(boxes[n, 3], query_boxes[k, 3]) - + * max(boxes[n, 1], query_boxes[k, 1]) + 1 # <<<<<<<<<<<<<< + * ) + * if ih > 0: + */ + __pyx_t_38 = __pyx_v_k; + __pyx_t_39 = 1; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_38 >= (size_t)__pyx_pybuffernd_query_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_39 < 0) { + __pyx_t_39 += __pyx_pybuffernd_query_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_39 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_39 >= __pyx_pybuffernd_query_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 101, __pyx_L1_error) + } + __pyx_t_32 = (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_query_boxes.rcbuffer->pybuffer.buf, __pyx_t_38, __pyx_pybuffernd_query_boxes.diminfo[0].strides, __pyx_t_39, __pyx_pybuffernd_query_boxes.diminfo[1].strides)); + __pyx_t_40 = __pyx_v_n; + __pyx_t_41 = 1; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_40 >= (size_t)__pyx_pybuffernd_boxes.diminfo[0].shape)) __pyx_t_11 = 0; + if (__pyx_t_41 < 0) { + __pyx_t_41 += __pyx_pybuffernd_boxes.diminfo[1].shape; + if (unlikely(__pyx_t_41 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_41 >= __pyx_pybuffernd_boxes.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 101, __pyx_L1_error) + } + __pyx_t_27 = (*__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_boxes.rcbuffer->pybuffer.buf, __pyx_t_40, __pyx_pybuffernd_boxes.diminfo[0].strides, __pyx_t_41, __pyx_pybuffernd_boxes.diminfo[1].strides)); + if (((__pyx_t_32 > __pyx_t_27) != 0)) { + __pyx_t_26 = __pyx_t_32; + } else { + __pyx_t_26 = __pyx_t_27; + } + + /* "model/utils/bbox.pyx":100 + * if iw > 0: + * ih = ( + * min(boxes[n, 3], query_boxes[k, 3]) - # <<<<<<<<<<<<<< + * max(boxes[n, 1], query_boxes[k, 1]) + 1 + * ) + */ + __pyx_v_ih = ((__pyx_t_23 - __pyx_t_26) + 1.0); + + /* "model/utils/bbox.pyx":103 + * max(boxes[n, 1], query_boxes[k, 1]) + 1 + * ) + * if ih > 0: # <<<<<<<<<<<<<< + * intersec[n, k] = iw * ih / box_area + * return intersec + */ + __pyx_t_33 = ((__pyx_v_ih > 0.0) != 0); + if (__pyx_t_33) { + + /* "model/utils/bbox.pyx":104 + * ) + * if ih > 0: + * intersec[n, k] = iw * ih / box_area # <<<<<<<<<<<<<< + * return intersec + */ + __pyx_t_26 = (__pyx_v_iw * __pyx_v_ih); + if (unlikely(__pyx_v_box_area == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "float division"); + __PYX_ERR(0, 104, __pyx_L1_error) + } + __pyx_t_42 = __pyx_v_n; + __pyx_t_43 = __pyx_v_k; + __pyx_t_11 = -1; + if (unlikely(__pyx_t_42 >= (size_t)__pyx_pybuffernd_intersec.diminfo[0].shape)) __pyx_t_11 = 0; + if (unlikely(__pyx_t_43 >= (size_t)__pyx_pybuffernd_intersec.diminfo[1].shape)) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 104, __pyx_L1_error) + } + *__Pyx_BufPtrStrided2d(__pyx_t_5model_5utils_11cython_bbox_DTYPE_t *, __pyx_pybuffernd_intersec.rcbuffer->pybuffer.buf, __pyx_t_42, __pyx_pybuffernd_intersec.diminfo[0].strides, __pyx_t_43, __pyx_pybuffernd_intersec.diminfo[1].strides) = (__pyx_t_26 / __pyx_v_box_area); + + /* "model/utils/bbox.pyx":103 + * max(boxes[n, 1], query_boxes[k, 1]) + 1 + * ) + * if ih > 0: # <<<<<<<<<<<<<< + * intersec[n, k] = iw * ih / box_area + * return intersec + */ + } + + /* "model/utils/bbox.pyx":98 + * max(boxes[n, 0], query_boxes[k, 0]) + 1 + * ) + * if iw > 0: # <<<<<<<<<<<<<< + * ih = ( + * min(boxes[n, 3], query_boxes[k, 3]) - + */ + } + } + } + + /* "model/utils/bbox.pyx":105 + * if ih > 0: + * intersec[n, k] = iw * ih / box_area + * return intersec # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_intersec)); + __pyx_r = ((PyArrayObject *)__pyx_v_intersec); + goto __pyx_L0; + + /* "model/utils/bbox.pyx":68 + * + * + * cdef np.ndarray[DTYPE_t, ndim=2] bbox_intersections_c( # <<<<<<<<<<<<<< + * np.ndarray[DTYPE_t, ndim=2] boxes, + * np.ndarray[DTYPE_t, ndim=2] query_boxes): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + { 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_SafeReleaseBuffer(&__pyx_pybuffernd_intersec.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("model.utils.cython_bbox.bbox_intersections_c", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_boxes.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_intersec.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_query_boxes.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_intersec); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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:; + + /* "../../opt/conda/envs/pytorch-py3.6/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)) { + + /* "../../opt/conda/envs/pytorch-py3.6/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_, 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) + + /* "../../opt/conda/envs/pytorch-py3.6/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") + */ + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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:; + + /* "../../opt/conda/envs/pytorch-py3.6/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)) { + + /* "../../opt/conda/envs/pytorch-py3.6/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__2, 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) + + /* "../../opt/conda/envs/pytorch-py3.6/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") + */ + } + + /* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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) { + + /* "../../opt/conda/envs/pytorch-py3.6/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)))); + + /* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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]); + + /* "../../opt/conda/envs/pytorch-py3.6/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]); + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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)); + + /* "../../opt/conda/envs/pytorch-py3.6/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:; + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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)); + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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) { + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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:; + + /* "../../opt/conda/envs/pytorch-py3.6/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:; + + /* "../../opt/conda/envs/pytorch-py3.6/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)) { + + /* "../../opt/conda/envs/pytorch-py3.6/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__3, 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) + + /* "../../opt/conda/envs/pytorch-py3.6/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") + */ + } + + /* "../../opt/conda/envs/pytorch-py3.6/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: + + /* "../../opt/conda/envs/pytorch-py3.6/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: + + /* "../../opt/conda/envs/pytorch-py3.6/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: + + /* "../../opt/conda/envs/pytorch-py3.6/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: + + /* "../../opt/conda/envs/pytorch-py3.6/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: + + /* "../../opt/conda/envs/pytorch-py3.6/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: + + /* "../../opt/conda/envs/pytorch-py3.6/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: + + /* "../../opt/conda/envs/pytorch-py3.6/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: + + /* "../../opt/conda/envs/pytorch-py3.6/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: + + /* "../../opt/conda/envs/pytorch-py3.6/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: + + /* "../../opt/conda/envs/pytorch-py3.6/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: + + /* "../../opt/conda/envs/pytorch-py3.6/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: + + /* "../../opt/conda/envs/pytorch-py3.6/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: + + /* "../../opt/conda/envs/pytorch-py3.6/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: + + /* "../../opt/conda/envs/pytorch-py3.6/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: + + /* "../../opt/conda/envs/pytorch-py3.6/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: + + /* "../../opt/conda/envs/pytorch-py3.6/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: + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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 + */ + } + + /* "../../opt/conda/envs/pytorch-py3.6/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)); + + /* "../../opt/conda/envs/pytorch-py3.6/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]) = '^'; + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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'; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; +} + +/* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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) { + + /* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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): + */ + } + + /* "../../opt/conda/envs/pytorch-py3.6/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) { + + /* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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 + */ + } + + /* "../../opt/conda/envs/pytorch-py3.6/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(); +} + +/* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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; +} + +/* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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; +} + +/* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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; +} + +/* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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; +} + +/* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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; +} + +/* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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) { + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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: + */ + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; +} + +/* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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)) { + + /* "../../opt/conda/envs/pytorch-py3.6/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__4, 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) + + /* "../../opt/conda/envs/pytorch-py3.6/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") + * + */ + } + + /* "../../opt/conda/envs/pytorch-py3.6/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:; + + /* "../../opt/conda/envs/pytorch-py3.6/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:; + + /* "../../opt/conda/envs/pytorch-py3.6/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)) { + + /* "../../opt/conda/envs/pytorch-py3.6/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__3, 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) + + /* "../../opt/conda/envs/pytorch-py3.6/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") + */ + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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); + } + + /* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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) { + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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)) { + + /* "../../opt/conda/envs/pytorch-py3.6/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__5, 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) + + /* "../../opt/conda/envs/pytorch-py3.6/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.") + * + */ + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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:; + + /* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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; + } + + /* "../../opt/conda/envs/pytorch-py3.6/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:; + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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; + + /* "../../opt/conda/envs/pytorch-py3.6/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; +} + +/* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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)); + + /* "../../opt/conda/envs/pytorch-py3.6/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(); +} + +/* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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); + + /* "../../opt/conda/envs/pytorch-py3.6/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 base + */ + __pyx_t_1 = ((__pyx_v_base == NULL) != 0); + if (__pyx_t_1) { + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1029 + * base = PyArray_BASE(arr) + * if base is NULL: + * return None # <<<<<<<<<<<<<< + * return base + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "../../opt/conda/envs/pytorch-py3.6/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 base + */ + } + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1030 + * if base is NULL: + * return None + * return base # <<<<<<<<<<<<<< + * + * # Versions of the import_* functions which are more suitable for + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_base)); + __pyx_r = ((PyObject *)__pyx_v_base); + goto __pyx_L0; + + /* "../../opt/conda/envs/pytorch-py3.6/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: + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1034 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * _import_array() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("import_array", 0); + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1035 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * _import_array() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1036 + * cdef inline int import_array() except -1: + * try: + * _import_array() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") + */ + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1036, __pyx_L3_error) + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1035 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * _import_array() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1037 + * try: + * _import_array() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.multiarray failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1037, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1038 + * _import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_umath() except -1: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1038, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 1038, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1035 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * _import_array() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1034 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * _import_array() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1040 + * raise ImportError("numpy.core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("import_umath", 0); + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1041 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1042 + * cdef inline int import_umath() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") + */ + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1042, __pyx_L3_error) + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1041 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1043 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") + * + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1043, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1044 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_ufunc() except -1: + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1044, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 1044, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1041 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1040 + * raise ImportError("numpy.core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1046 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + +static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + __Pyx_RefNannySetupContext("import_ufunc", 0); + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1047 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1048 + * cdef inline int import_ufunc() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy.core.umath failed to import") + */ + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 1048, __pyx_L3_error) + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1047 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1049 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy.core.umath failed to import") + */ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(1, 1049, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GOTREF(__pyx_t_7); + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1050 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + */ + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_ImportError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1050, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(1, 1050, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1047 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: + */ + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1046 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_cython_bbox(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_cython_bbox}, + {0, NULL} +}; +#endif + +static struct PyModuleDef __pyx_moduledef = { + PyModuleDef_HEAD_INIT, + "cython_bbox", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_DTYPE, __pyx_k_DTYPE, sizeof(__pyx_k_DTYPE), 0, 0, 1, 1}, + {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, + {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, + {&__pyx_n_s_ImportError, __pyx_k_ImportError, sizeof(__pyx_k_ImportError), 0, 0, 1, 1}, + {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, + {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_bbox_intersections, __pyx_k_bbox_intersections, sizeof(__pyx_k_bbox_intersections), 0, 0, 1, 1}, + {&__pyx_n_s_bbox_overlaps, __pyx_k_bbox_overlaps, sizeof(__pyx_k_bbox_overlaps), 0, 0, 1, 1}, + {&__pyx_n_s_boxes, __pyx_k_boxes, sizeof(__pyx_k_boxes), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, + {&__pyx_n_s_float, __pyx_k_float, sizeof(__pyx_k_float), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_kp_s_model_utils_bbox_pyx, __pyx_k_model_utils_bbox_pyx, sizeof(__pyx_k_model_utils_bbox_pyx), 0, 0, 1, 0}, + {&__pyx_n_s_model_utils_cython_bbox, __pyx_k_model_utils_cython_bbox, sizeof(__pyx_k_model_utils_cython_bbox), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, + {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, + {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_kp_s_numpy_core_multiarray_failed_to, __pyx_k_numpy_core_multiarray_failed_to, sizeof(__pyx_k_numpy_core_multiarray_failed_to), 0, 0, 1, 0}, + {&__pyx_kp_s_numpy_core_umath_failed_to_impor, __pyx_k_numpy_core_umath_failed_to_impor, sizeof(__pyx_k_numpy_core_umath_failed_to_impor), 0, 0, 1, 0}, + {&__pyx_n_s_query_boxes, __pyx_k_query_boxes, sizeof(__pyx_k_query_boxes), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, + {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 37, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 272, __pyx_L1_error) + __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 856, __pyx_L1_error) + __pyx_builtin_ImportError = __Pyx_GetBuiltinName(__pyx_n_s_ImportError); if (!__pyx_builtin_ImportError) __PYX_ERR(1, 1038, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "../../opt/conda/envs/pytorch-py3.6/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_tuple_ = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "../../opt/conda/envs/pytorch-py3.6/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_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "../../opt/conda/envs/pytorch-py3.6/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_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "../../opt/conda/envs/pytorch-py3.6/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_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 856, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "../../opt/conda/envs/pytorch-py3.6/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_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 880, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1038 + * _import_array() + * except Exception: + * raise ImportError("numpy.core.multiarray failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_umath() except -1: + */ + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_multiarray_failed_to); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 1038, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1044 + * _import_umath() + * except Exception: + * raise ImportError("numpy.core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_ufunc() except -1: + */ + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_numpy_core_umath_failed_to_impor); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 1044, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + + /* "model/utils/bbox.pyx":15 + * ctypedef np.float_t DTYPE_t + * + * def bbox_overlaps(np.ndarray[DTYPE_t, ndim=2] boxes, # <<<<<<<<<<<<<< + * np.ndarray[DTYPE_t, ndim=2] query_boxes): + * return bbox_overlaps_c(boxes, query_boxes) + */ + __pyx_tuple__8 = PyTuple_Pack(2, __pyx_n_s_boxes, __pyx_n_s_query_boxes); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_model_utils_bbox_pyx, __pyx_n_s_bbox_overlaps, 15, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 15, __pyx_L1_error) + + /* "model/utils/bbox.pyx":62 + * + * + * def bbox_intersections( # <<<<<<<<<<<<<< + * np.ndarray[DTYPE_t, ndim=2] boxes, + * np.ndarray[DTYPE_t, ndim=2] query_boxes): + */ + __pyx_tuple__10 = PyTuple_Pack(2, __pyx_n_s_boxes, __pyx_n_s_query_boxes); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_model_utils_bbox_pyx, __pyx_n_s_bbox_intersections, 62, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ + +static int __Pyx_modinit_global_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(2, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_ptype_5numpy_dtype = __Pyx_ImportType(__pyx_t_1, "numpy", "dtype", sizeof(PyArray_Descr), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_dtype) __PYX_ERR(1, 206, __pyx_L1_error) + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType(__pyx_t_1, "numpy", "flatiter", sizeof(PyArrayIterObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_flatiter) __PYX_ERR(1, 229, __pyx_L1_error) + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType(__pyx_t_1, "numpy", "broadcast", sizeof(PyArrayMultiIterObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_broadcast) __PYX_ERR(1, 233, __pyx_L1_error) + __pyx_ptype_5numpy_ndarray = __Pyx_ImportType(__pyx_t_1, "numpy", "ndarray", sizeof(PyArrayObject), __Pyx_ImportType_CheckSize_Ignore); + if (!__pyx_ptype_5numpy_ndarray) __PYX_ERR(1, 242, __pyx_L1_error) + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType(__pyx_t_1, "numpy", "ufunc", sizeof(PyUFuncObject), __Pyx_ImportType_CheckSize_Warn); + if (!__pyx_ptype_5numpy_ufunc) __PYX_ERR(1, 918, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + + +#if PY_MAJOR_VERSION < 3 +#ifdef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC void +#else +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#endif +#else +#ifdef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#endif +#endif + + +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initcython_bbox(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initcython_bbox(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_cython_bbox(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_cython_bbox(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + #if PY_VERSION_HEX >= 0x030700A1 + static PY_INT64_T main_interpreter_id = -1; + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return (unlikely(current_id == -1)) ? -1 : 0; + } else if (unlikely(main_interpreter_id != current_id)) + #else + static PyInterpreterState *main_interpreter = NULL; + PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; + if (!main_interpreter) { + main_interpreter = current_interpreter; + } else if (unlikely(main_interpreter != current_interpreter)) + #endif + { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { + result = PyDict_SetItemString(moddict, to_name, value); + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + if (__Pyx_check_single_interpreter()) + return NULL; + if (__pyx_m) + return __Pyx_NewRef(__pyx_m); + modname = PyObject_GetAttrString(spec, "name"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static CYTHON_SMALL_CODE int __pyx_pymod_exec_cython_bbox(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'cython_bbox' has already been imported. Re-initialisation is not supported."); + return -1; + } + #elif PY_MAJOR_VERSION >= 3 + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + #if CYTHON_REFNANNY +__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); +if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); +} +#endif + __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_cython_bbox(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("cython_bbox", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_b); + __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_cython_runtime); + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_model__utils__cython_bbox) { + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "model.utils.cython_bbox")) { + if (unlikely(PyDict_SetItemString(modules, "model.utils.cython_bbox", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) goto __pyx_L1_error; + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) goto __pyx_L1_error; + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(); + (void)__Pyx_modinit_variable_export_code(); + (void)__Pyx_modinit_function_export_code(); + (void)__Pyx_modinit_type_init_code(); + if (unlikely(__Pyx_modinit_type_import_code() != 0)) goto __pyx_L1_error; + (void)__Pyx_modinit_variable_import_code(); + (void)__Pyx_modinit_function_import_code(); + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + + /* "model/utils/bbox.pyx":9 + * + * cimport cython + * import numpy as np # <<<<<<<<<<<<<< + * cimport numpy as np + * + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_1) < 0) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "model/utils/bbox.pyx":12 + * cimport numpy as np + * + * DTYPE = np.float # <<<<<<<<<<<<<< + * ctypedef np.float_t DTYPE_t + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_np); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_float); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_DTYPE, __pyx_t_2) < 0) __PYX_ERR(0, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "model/utils/bbox.pyx":15 + * ctypedef np.float_t DTYPE_t + * + * def bbox_overlaps(np.ndarray[DTYPE_t, ndim=2] boxes, # <<<<<<<<<<<<<< + * np.ndarray[DTYPE_t, ndim=2] query_boxes): + * return bbox_overlaps_c(boxes, query_boxes) + */ + __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5model_5utils_11cython_bbox_1bbox_overlaps, NULL, __pyx_n_s_model_utils_cython_bbox); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_bbox_overlaps, __pyx_t_2) < 0) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "model/utils/bbox.pyx":62 + * + * + * def bbox_intersections( # <<<<<<<<<<<<<< + * np.ndarray[DTYPE_t, ndim=2] boxes, + * np.ndarray[DTYPE_t, ndim=2] query_boxes): + */ + __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_5model_5utils_11cython_bbox_3bbox_intersections, NULL, __pyx_n_s_model_utils_cython_bbox); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_bbox_intersections, __pyx_t_2) < 0) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "model/utils/bbox.pyx":1 + * # -------------------------------------------------------- # <<<<<<<<<<<<<< + * # Fast R-CNN + * # Copyright (c) 2015 Microsoft + */ + __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "../../opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/Cython/Includes/numpy/__init__.pxd":1046 + * raise ImportError("numpy.core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init model.utils.cython_bbox", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_CLEAR(__pyx_m); + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init model.utils.cython_bbox"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #elif PY_MAJOR_VERSION >= 3 + return __pyx_m; + #else + return; + #endif +} + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* PyObjectGetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* RaiseArgTupleInvalid */ +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) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* RaiseDoubleKeywords */ +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (exact) { + #if PY_MAJOR_VERSION == 2 + if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); + return 0; +} + +/* IsLittleEndian */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) +{ + union { + uint32_t u32; + uint8_t u8[4]; + } S; + S.u32 = 0x01020304; + return S.u8[0] == 4; +} + +/* BufferFormatCheck */ +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type) { + stack[0].field = &ctx->root; + stack[0].parent_offset = 0; + ctx->root.type = type; + ctx->root.name = "buffer dtype"; + ctx->root.offset = 0; + ctx->head = stack; + ctx->head->field = &ctx->root; + ctx->fmt_offset = 0; + ctx->head->parent_offset = 0; + ctx->new_packmode = '@'; + ctx->enc_packmode = '@'; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->is_complex = 0; + ctx->is_valid_array = 0; + ctx->struct_alignment = 0; + while (type->typegroup == 'S') { + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = 0; + type = type->fields->type; + } +} +static int __Pyx_BufFmt_ParseNumber(const char** ts) { + int count; + const char* t = *ts; + if (*t < '0' || *t > '9') { + return -1; + } else { + count = *t++ - '0'; + while (*t >= '0' && *t <= '9') { + count *= 10; + count += *t++ - '0'; + } + } + *ts = t; + return count; +} +static int __Pyx_BufFmt_ExpectNumber(const char **ts) { + int number = __Pyx_BufFmt_ParseNumber(ts); + if (number == -1) + PyErr_Format(PyExc_ValueError,\ + "Does not understand character buffer dtype format string ('%c')", **ts); + return number; +} +static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { + PyErr_Format(PyExc_ValueError, + "Unexpected format string character: '%c'", ch); +} +static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { + switch (ch) { + case '?': return "'bool'"; + case 'c': return "'char'"; + case 'b': return "'signed char'"; + case 'B': return "'unsigned char'"; + case 'h': return "'short'"; + case 'H': return "'unsigned short'"; + case 'i': return "'int'"; + case 'I': return "'unsigned int'"; + case 'l': return "'long'"; + case 'L': return "'unsigned long'"; + case 'q': return "'long long'"; + case 'Q': return "'unsigned long long'"; + case 'f': return (is_complex ? "'complex float'" : "'float'"); + case 'd': return (is_complex ? "'complex double'" : "'double'"); + case 'g': return (is_complex ? "'complex long double'" : "'long double'"); + case 'T': return "a struct"; + case 'O': return "Python object"; + case 'P': return "a pointer"; + case 's': case 'p': return "a string"; + case 0: return "end"; + default: return "unparseable format string"; + } +} +static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return 2; + case 'i': case 'I': case 'l': case 'L': return 4; + case 'q': case 'Q': return 8; + case 'f': return (is_complex ? 8 : 4); + case 'd': return (is_complex ? 16 : 8); + case 'g': { + PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); + return 0; + } + case 'O': case 'P': return sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(short); + case 'i': case 'I': return sizeof(int); + case 'l': case 'L': return sizeof(long); + #ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(PY_LONG_LONG); + #endif + case 'f': return sizeof(float) * (is_complex ? 2 : 1); + case 'd': return sizeof(double) * (is_complex ? 2 : 1); + case 'g': return sizeof(long double) * (is_complex ? 2 : 1); + case 'O': case 'P': return sizeof(void*); + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +typedef struct { char c; short x; } __Pyx_st_short; +typedef struct { char c; int x; } __Pyx_st_int; +typedef struct { char c; long x; } __Pyx_st_long; +typedef struct { char c; float x; } __Pyx_st_float; +typedef struct { char c; double x; } __Pyx_st_double; +typedef struct { char c; long double x; } __Pyx_st_longdouble; +typedef struct { char c; void *x; } __Pyx_st_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_st_float) - sizeof(float); + case 'd': return sizeof(__Pyx_st_double) - sizeof(double); + case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +/* These are for computing the padding at the end of the struct to align + on the first member of the struct. This will probably the same as above, + but we don't have any guarantees. + */ +typedef struct { short x; char c; } __Pyx_pad_short; +typedef struct { int x; char c; } __Pyx_pad_int; +typedef struct { long x; char c; } __Pyx_pad_long; +typedef struct { float x; char c; } __Pyx_pad_float; +typedef struct { double x; char c; } __Pyx_pad_double; +typedef struct { long double x; char c; } __Pyx_pad_longdouble; +typedef struct { void *x; char c; } __Pyx_pad_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); + case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); + case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { + switch (ch) { + case 'c': + return 'H'; + case 'b': case 'h': case 'i': + case 'l': case 'q': case 's': case 'p': + return 'I'; + case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': + return 'U'; + case 'f': case 'd': case 'g': + return (is_complex ? 'C' : 'R'); + case 'O': + return 'O'; + case 'P': + return 'P'; + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { + if (ctx->head == NULL || ctx->head->field == &ctx->root) { + const char* expected; + const char* quote; + if (ctx->head == NULL) { + expected = "end"; + quote = ""; + } else { + expected = ctx->head->field->type->name; + quote = "'"; + } + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected %s%s%s but got %s", + quote, expected, quote, + __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); + } else { + __Pyx_StructField* field = ctx->head->field; + __Pyx_StructField* parent = (ctx->head - 1)->field; + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", + field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), + parent->type->name, field->name); + } +} +static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { + char group; + size_t size, offset, arraysize = 1; + if (ctx->enc_type == 0) return 0; + if (ctx->head->field->type->arraysize[0]) { + int i, ndim = 0; + if (ctx->enc_type == 's' || ctx->enc_type == 'p') { + ctx->is_valid_array = ctx->head->field->type->ndim == 1; + ndim = 1; + if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %zu", + ctx->head->field->type->arraysize[0], ctx->enc_count); + return -1; + } + } + if (!ctx->is_valid_array) { + PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", + ctx->head->field->type->ndim, ndim); + return -1; + } + for (i = 0; i < ctx->head->field->type->ndim; i++) { + arraysize *= ctx->head->field->type->arraysize[i]; + } + ctx->is_valid_array = 0; + ctx->enc_count = 1; + } + group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); + do { + __Pyx_StructField* field = ctx->head->field; + __Pyx_TypeInfo* type = field->type; + if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { + size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); + } else { + size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); + } + if (ctx->enc_packmode == '@') { + size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); + size_t align_mod_offset; + if (align_at == 0) return -1; + align_mod_offset = ctx->fmt_offset % align_at; + if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; + if (ctx->struct_alignment == 0) + ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, + ctx->is_complex); + } + if (type->size != size || type->typegroup != group) { + if (type->typegroup == 'C' && type->fields != NULL) { + size_t parent_offset = ctx->head->parent_offset + field->offset; + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = parent_offset; + continue; + } + if ((type->typegroup == 'H' || group == 'H') && type->size == size) { + } else { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + } + offset = ctx->head->parent_offset + field->offset; + if (ctx->fmt_offset != offset) { + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", + (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); + return -1; + } + ctx->fmt_offset += size; + if (arraysize) + ctx->fmt_offset += (arraysize - 1) * size; + --ctx->enc_count; + while (1) { + if (field == &ctx->root) { + ctx->head = NULL; + if (ctx->enc_count != 0) { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + break; + } + ctx->head->field = ++field; + if (field->type == NULL) { + --ctx->head; + field = ctx->head->field; + continue; + } else if (field->type->typegroup == 'S') { + size_t parent_offset = ctx->head->parent_offset + field->offset; + if (field->type->fields->type == NULL) continue; + field = field->type->fields; + ++ctx->head; + ctx->head->field = field; + ctx->head->parent_offset = parent_offset; + break; + } else { + break; + } + } + } while (ctx->enc_count); + ctx->enc_type = 0; + ctx->is_complex = 0; + return 0; +} +static PyObject * +__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) +{ + const char *ts = *tsp; + int i = 0, number; + int ndim = ctx->head->field->type->ndim; +; + ++ts; + if (ctx->new_count != 1) { + PyErr_SetString(PyExc_ValueError, + "Cannot handle repeated arrays in format string"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + while (*ts && *ts != ')') { + switch (*ts) { + case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; + default: break; + } + number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) + return PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + if (*ts != ',' && *ts != ')') + return PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + if (*ts == ',') ts++; + i++; + } + if (i != ndim) + return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return NULL; + } + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return Py_None; +} +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { + int got_Z = 0; + while (1) { + switch(*ts) { + case 0: + if (ctx->enc_type != 0 && ctx->head == NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (ctx->head != NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + return ts; + case ' ': + case '\r': + case '\n': + ++ts; + break; + case '<': + if (!__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '>': + case '!': + if (__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '=': + case '@': + case '^': + ctx->new_packmode = *ts++; + break; + case 'T': + { + const char* ts_after_sub; + size_t i, struct_count = ctx->new_count; + size_t struct_alignment = ctx->struct_alignment; + ctx->new_count = 1; + ++ts; + if (*ts != '{') { + PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + ctx->enc_count = 0; + ctx->struct_alignment = 0; + ++ts; + ts_after_sub = ts; + for (i = 0; i != struct_count; ++i) { + ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); + if (!ts_after_sub) return NULL; + } + ts = ts_after_sub; + if (struct_alignment) ctx->struct_alignment = struct_alignment; + } + break; + case '}': + { + size_t alignment = ctx->struct_alignment; + ++ts; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + if (alignment && ctx->fmt_offset % alignment) { + ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); + } + } + return ts; + case 'x': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->fmt_offset += ctx->new_count; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->enc_packmode = ctx->new_packmode; + ++ts; + break; + case 'Z': + got_Z = 1; + ++ts; + if (*ts != 'f' && *ts != 'd' && *ts != 'g') { + __Pyx_BufFmt_RaiseUnexpectedChar('Z'); + return NULL; + } + CYTHON_FALLTHROUGH; + case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'l': case 'L': case 'q': case 'Q': + case 'f': case 'd': case 'g': + case 'O': case 'p': + if (ctx->enc_type == *ts && got_Z == ctx->is_complex && + ctx->enc_packmode == ctx->new_packmode) { + ctx->enc_count += ctx->new_count; + ctx->new_count = 1; + got_Z = 0; + ++ts; + break; + } + CYTHON_FALLTHROUGH; + case 's': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_count = ctx->new_count; + ctx->enc_packmode = ctx->new_packmode; + ctx->enc_type = *ts; + ctx->is_complex = got_Z; + ++ts; + ctx->new_count = 1; + got_Z = 0; + break; + case ':': + ++ts; + while(*ts != ':') ++ts; + ++ts; + break; + case '(': + if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; + } + } + } +} + +/* BufferGetAndValidate */ + static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { + if (unlikely(info->buf == NULL)) return; + if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; + __Pyx_ReleaseBuffer(info); +} +static void __Pyx_ZeroBuffer(Py_buffer* buf) { + buf->buf = NULL; + buf->obj = NULL; + buf->strides = __Pyx_zeros; + buf->shape = __Pyx_zeros; + buf->suboffsets = __Pyx_minusones; +} +static int __Pyx__GetBufferAndValidate( + Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, + int nd, int cast, __Pyx_BufFmt_StackElem* stack) +{ + buf->buf = NULL; + if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) { + __Pyx_ZeroBuffer(buf); + return -1; + } + if (unlikely(buf->ndim != nd)) { + PyErr_Format(PyExc_ValueError, + "Buffer has wrong number of dimensions (expected %d, got %d)", + nd, buf->ndim); + goto fail; + } + if (!cast) { + __Pyx_BufFmt_Context ctx; + __Pyx_BufFmt_Init(&ctx, stack, dtype); + if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; + } + if (unlikely((size_t)buf->itemsize != dtype->size)) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", + buf->itemsize, (buf->itemsize > 1) ? "s" : "", + dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); + goto fail; + } + if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; + return 0; +fail:; + __Pyx_SafeReleaseBuffer(buf); + return -1; +} + +/* PyErrFetchRestore */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* PyDictVersioning */ + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif + } + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); +} +#endif + +/* GetModuleGlobalName */ + #if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 + result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } else if (unlikely(PyErr_Occurred())) { + return NULL; + } +#else + result = PyDict_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } +#endif +#else + result = PyObject_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + +/* PyObjectCall */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* ExtTypeTest */ + static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +/* BufferIndexError */ + static void __Pyx_RaiseBufferIndexError(int axis) { + PyErr_Format(PyExc_IndexError, + "Out of bounds on buffer access (axis %d)", axis); +} + +/* RaiseException */ + #if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +/* PyCFunctionFastCall */ + #if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + int flags = PyCFunction_GET_FLAGS(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { + return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); + } else { + return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + } +} +#endif + +/* PyFunctionFastCall */ + #if CYTHON_FAST_PYCALL +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif +#endif + +/* PyObjectCallMethO */ + #if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallOneArg */ + #if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif + if (likely(PyCFunction_Check(func))) { + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* DictGetItem */ + #if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + if (unlikely(PyTuple_Check(key))) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) { + PyErr_SetObject(PyExc_KeyError, args); + Py_DECREF(args); + } + } else { + PyErr_SetObject(PyExc_KeyError, key); + } + } + return NULL; + } + Py_INCREF(value); + return value; +} +#endif + +/* RaiseTooManyValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +/* RaiseNeedMoreValuesToUnpack */ + static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +/* RaiseNoneIterError */ + static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +/* GetTopmostException */ + #if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; + } + return exc_info; +} +#endif + +/* SaveResetException */ + #if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + #endif + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +#endif + +/* PyErrExceptionMatches */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; icurexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + if (unlikely(PyTuple_Check(err))) + return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); +} +#endif + +/* GetException */ + #if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) +#endif +{ + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + } + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +} + +/* TypeImport */ + #ifndef __PYX_HAVE_RT_ImportType +#define __PYX_HAVE_RT_ImportType +static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, + size_t size, enum __Pyx_ImportType_CheckSize check_size) +{ + PyObject *result = 0; + char warning[200]; + Py_ssize_t basicsize; +#ifdef Py_LIMITED_API + PyObject *py_basicsize; +#endif + result = PyObject_GetAttrString(module, class_name); + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#ifndef Py_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; +#else + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if ((size_t)basicsize < size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + goto bad; + } + if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + goto bad; + } + else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(result); + return NULL; +} +#endif + +/* Import */ + static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.')) { + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_MAJOR_VERSION < 3 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +/* CLineInTraceback */ + #ifndef CYTHON_CLINE_IN_TRACEBACK +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { + PyObject *use_cline; + PyObject *ptype, *pvalue, *ptraceback; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict; +#endif + if (unlikely(!__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, *cython_runtime_dict, + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) + } else +#endif + { + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } + } + if (!use_cline) { + c_line = 0; + PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + } + else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache */ + static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ + #include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); + } + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#if PY_MAJOR_VERSION < 3 +static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { + if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); + if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags); + PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); + return -1; +} +static void __Pyx_ReleaseBuffer(Py_buffer *view) { + PyObject *obj = view->obj; + if (!obj) return; + if (PyObject_CheckBuffer(obj)) { + PyBuffer_Release(view); + return; + } + if ((0)) {} + else if (__Pyx_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); + view->obj = NULL; + Py_DECREF(obj); +} +#endif + + + /* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value) { + const unsigned int neg_one = (unsigned int) ((unsigned int) 0 - (unsigned int) 1), const_zero = (unsigned int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(unsigned int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(unsigned int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(unsigned int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(unsigned int), + little, !is_unsigned); + } +} + +/* CIntFromPyVerify */ + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* Declarations */ + #if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return ::std::complex< float >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return x + y*(__pyx_t_float_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + __pyx_t_float_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +/* Arithmetic */ + #if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + if (b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabsf(b.real) >= fabsf(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + float r = b.imag / b.real; + float s = (float)(1.0) / (b.real + b.imag * r); + return __pyx_t_float_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + float r = b.real / b.imag; + float s = (float)(1.0) / (b.imag + b.real * r); + return __pyx_t_float_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + if (b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + float denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_float_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtf(z.real*z.real + z.imag*z.imag); + #else + return hypotf(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + float denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_float(a, a); + case 3: + z = __Pyx_c_prod_float(a, a); + return __Pyx_c_prod_float(z, a); + case 4: + z = __Pyx_c_prod_float(a, a); + return __Pyx_c_prod_float(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if (b.imag == 0) { + z.real = powf(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2f(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_float(a); + theta = atan2f(a.imag, a.real); + } + lnr = logf(r); + z_r = expf(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosf(z_theta); + z.imag = z_r * sinf(z_theta); + return z; + } + #endif +#endif + +/* Declarations */ + #if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return ::std::complex< double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return x + y*(__pyx_t_double_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + __pyx_t_double_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +/* Arithmetic */ + #if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + if (b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabs(b.real) >= fabs(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + double r = b.imag / b.real; + double s = (double)(1.0) / (b.real + b.imag * r); + return __pyx_t_double_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + double r = b.real / b.imag; + double s = (double)(1.0) / (b.imag + b.real * r); + return __pyx_t_double_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + if (b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + double denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_double_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrt(z.real*z.real + z.imag*z.imag); + #else + return hypot(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_double(a, a); + case 3: + z = __Pyx_c_prod_double(a, a); + return __Pyx_c_prod_double(z, a); + case 4: + z = __Pyx_c_prod_double(a, a); + return __Pyx_c_prod_double(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if (b.imag == 0) { + z.real = pow(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_double(a); + theta = atan2(a.imag, a.real); + } + lnr = log(r); + z_r = exp(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cos(z_theta); + z.imag = z_r * sin(z_theta); + return z; + } + #endif +#endif + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { + const enum NPY_TYPES neg_one = (enum NPY_TYPES) ((enum NPY_TYPES) 0 - (enum NPY_TYPES) 1), const_zero = (enum NPY_TYPES) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(enum NPY_TYPES) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(enum NPY_TYPES) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) { + const unsigned int neg_one = (unsigned int) ((unsigned int) 0 - (unsigned int) 1), const_zero = (unsigned int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(unsigned int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (unsigned int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (unsigned int) 0; + case 1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, digits[0]) + case 2: + if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT) { + return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT) { + return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) >= 4 * PyLong_SHIFT) { + return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (unsigned int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(unsigned int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (unsigned int) 0; + case -1: __PYX_VERIFY_RETURN_INT(unsigned int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, +digits[0]) + case -2: + if (8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { + return (unsigned int) (((unsigned int)-1)*(((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { + return (unsigned int) ((((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { + return (unsigned int) (((unsigned int)-1)*(((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { + return (unsigned int) ((((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) { + return (unsigned int) (((unsigned int)-1)*(((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT) { + return (unsigned int) ((((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(unsigned int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + unsigned int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (unsigned int) -1; + } + } else { + unsigned int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (unsigned int) -1; + val = __Pyx_PyInt_As_unsigned_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to unsigned int"); + return (unsigned int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to unsigned int"); + return (unsigned int) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* FastTypeChecks */ + #if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = a->tp_base; + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(a, b); +} +#if PY_MAJOR_VERSION == 2 +static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { + PyObject *exception, *value, *tb; + int res; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&exception, &value, &tb); + res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + if (!res) { + res = PyObject_IsSubclass(err, exc_type2); + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + } + __Pyx_ErrRestore(exception, value, tb); + return res; +} +#else +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; + if (!res) { + res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } + return res; +} +#endif +static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + assert(PyExceptionClass_Check(exc_type)); + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; ip) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + if (PyObject_Hash(*t->p) == -1) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#if !CYTHON_PEP393_ENABLED +static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +} +#else +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (likely(PyUnicode_IS_ASCII(o))) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +} +#endif +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { + int retval; + if (unlikely(!x)) return -1; + retval = __Pyx_PyObject_IsTrue(x); + Py_DECREF(x); + return retval; +} +static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { +#if PY_MAJOR_VERSION >= 3 + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type %.200s). " + "The ability to return an instance of a strict subclass of int " + "is deprecated, and may be removed in a future version of Python.", + Py_TYPE(result)->tp_name)) { + Py_DECREF(result); + return NULL; + } + return result; + } +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + type_name, type_name, Py_TYPE(result)->tp_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x) || PyLong_Check(x))) +#else + if (likely(PyLong_Check(x))) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = m->nb_int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = m->nb_long(x); + } + #else + if (likely(m && m->nb_int)) { + name = "int"; + res = m->nb_int(x); + } + #endif +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Int(x); + } +#endif + if (likely(res)) { +#if PY_MAJOR_VERSION < 3 + if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { +#else + if (unlikely(!PyLong_CheckExact(res))) { +#endif + return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(b); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/pytorch-coviar b/pytorch-coviar new file mode 160000 index 0000000..4f0857a --- /dev/null +++ b/pytorch-coviar @@ -0,0 +1 @@ +Subproject commit 4f0857a37ac9e283fcd9ebede950f33057d07eba diff --git a/requirements.txt b/requirements.txt new file mode 100755 index 0000000..8ed1af5 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,10 @@ +cffi==1.13.2 +Cython==0.29.14 +easydict==1.9 +matplotlib==3.1.2 +opencv-python==4.1.2.30 +pandas==0.25.3 +Pillow==6.2.2 +sklearn +torch==0.3.1 +torchvision==0.2.1 diff --git a/tracking_on_mot.py b/tracking_on_mot.py index 345dcb5..3e12ff9 100644 --- a/tracking_on_mot.py +++ b/tracking_on_mot.py @@ -21,7 +21,7 @@ def parse_args(): Parse input arguments """ parser = argparse.ArgumentParser(description='Train a Fast R-CNN network') - parser.add_argument('--mot_dir', default='/home/liuqk/Dataset/MOT', + parser.add_argument('--mot_dir', default='data', help='training dataset', type=str) parser.add_argument('--cfg_file', help='optional config file', @@ -63,8 +63,8 @@ def parse_args(): else: args.mGPUs = False - args.dataset_year = ['MOT16'] # ['MOT16', 'MOT17'] - args.detectors = ['DPM']#, 'SDP', 'FRCNN'] # ['PRIVATE', 'DPM', 'SDP', 'FRCNN', 'POI'] + args.dataset_year = ['MOT17'] # ['MOT16', 'MOT17'] + args.detectors = ['FRCNN']#, 'SDP', 'FRCNN'] # ['PRIVATE', 'DPM', 'SDP', 'FRCNN', 'POI'] args.stage = ['test'] # ['test', 'val'] print(args.stage) @@ -207,7 +207,7 @@ def parse_args(): print('tracking on ' + seq + ' using ' + det_name + ' detector ...') - video_file = os.path.join(args.mot_dir, one_dataset, s, seq, seq + '.mp4') + video_file = os.path.join(args.mot_dir, one_dataset, s, seq, seq + '-mpeg4-1.0.mp4') if not os.path.exists(video_file): raise RuntimeError(video_file + ' does not exists') From 286d082de9385b978df0bcc428e9821547641c3e Mon Sep 17 00:00:00 2001 From: LukasBommes Date: Wed, 8 Jan 2020 16:23:04 +0800 Subject: [PATCH 2/6] reverted changes to detection.py --- docker-compose-new.yml | 16 ---- docker-compose.yml | 2 + docker-entrypoint.sh | 18 +---- lib/model/nms/_ext/nms/_nms.so | Bin 61672 -> 61392 bytes lib/model/nms/src/nms_cuda_kernel.cu.o | Bin 36352 -> 36352 bytes lib/tracking/detection.py | 106 ++++++++++++++++++++++++- 6 files changed, 109 insertions(+), 33 deletions(-) delete mode 100755 docker-compose-new.yml diff --git a/docker-compose-new.yml b/docker-compose-new.yml deleted file mode 100755 index fbbcb25..0000000 --- a/docker-compose-new.yml +++ /dev/null @@ -1,16 +0,0 @@ -version: "2.3" - -services: - - otcd_pytorch_1_3: - container_name: otcd_pytorch_1_3 - image: pytorch6 - runtime: nvidia - environment: - - DISPLAY - ipc: host # for GUI - volumes: - - /tmp/.X11-unix:/tmp/.X11-unix:rw # for GUI access - - .:/workspace - entrypoint: ./docker-entrypoint.sh - command: tail -f /dev/null diff --git a/docker-compose.yml b/docker-compose.yml index 729a0fa..1907849 100755 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -13,3 +13,5 @@ services: - /tmp/.X11-unix:/tmp/.X11-unix:rw # for GUI access - .:/workspace - /home/lukas/mv-tracker/data:/workspace/data + entrypoint: ./docker-entrypoint.sh + command: tail -f /dev/null diff --git a/docker-entrypoint.sh b/docker-entrypoint.sh index 34cb98f..1657b23 100755 --- a/docker-entrypoint.sh +++ b/docker-entrypoint.sh @@ -1,21 +1,7 @@ #!/bin/sh set -e -conda install -y av -c conda-forge # needed to fix ffmpeg error during torchvision build -export FORCE_CUDA=1 -cd /opt/pytorch -rm -rf vision -git config --global user.email "Lukas.Bommes@gmx.de" -git config --global user.name "LukasBommes" -git clone https://github.com/LukasBommes/vision.git -cd vision -pip install -v . -cd /workspace - -# temporary workaround for torchvision issue #1712 (incompatibility with pillow 7.0.0) -pip install 'pillow<7' - -# install coviar -cd /workspace && chmod +x install.sh && ./install.sh +cd /workspace/lib/model/roi_align && chmod +x install.sh && ./install.sh +cd /workspace/lib/model/nms && chmod +x make.sh && ./make.sh exec "$@" diff --git a/lib/model/nms/_ext/nms/_nms.so b/lib/model/nms/_ext/nms/_nms.so index bcd70a5270628ce0c22b7d3cb8034c959ddc089e..fdbfdfe2300ce51a72edc6c421103dfea718c40b 100755 GIT binary patch literal 61392 zcmeFa34Bw>)i*p>vZO27mSh=$*#$9Rz}S{I%$C?-gPa&}FeVTnLddeMU`vV?u(K2= zK!fW#g=Q&j)0QS_l5Tm@Hf__iO-V{2X`6w6D z*STyq=QX5A7u4?aD=4*O%*7F;!-&7LtsF$@;uW<#oT=bXW+|oGP6v?M9qCl?M><`+ zqLwE`SJYBg*jNTi`g=mq)60CpruVprA3eUl`qV1VAFGCL|I-^2o2cbh{JHT* zej!m(&+@$)I^E?NlX_$q+dq@(X1c0pVt9Ml6SB-^vg(ZORn-E^9}sn#7Ht}QyQco?2I-rVduAN{`SHv3`>u$s zoUr|YbDyjE$)CMTj(x9p-XjgS?|MD->L1>;{^ZO9=enm_mpT0RPYAz%=1=#{yz#or zF3lb~fAI37-}uA5fB8xOTh_qS(Um`a=IY0@dfQ*@=hhDHdgFm}_xxhQRrMeK?fr``c4l=S`rNXX>u!0QKM~`lft^DzId!P8sZ@S*N zqV<7uE9(CA+S{4;y!qm_woTuCZ-@fXZ(q%<|ec{Z`n>F3NpsGjYo|rWpU5&(` z&LJ(uFbcjM!9NoJ6f|~e1&DeFCfZ2+<)h%A8%6JvkT;T?OEGar!ml4izGoEtFGs;Y zH46R>*y9+XzgLdJe_#~;pISz?|Km~o@b^*tFk=+GzZu0pEu-KehPm*Ue!Vh^J)Z*O zNdCWn6#R>$=*=9({>w+vYaB(+gQLj#!YKAsj3VdmQO0G2K)(%&?aKL{XrC+mQ=ScD&8O0vT`7=k5e`CY+{yMQh3bUAB=shgtUnTgDVuM2b=LP;6fgg|3!Lr$%7Yl?arVIXU zY4#itc3v;=R}20-1b>7Ua$FvzU<-tu17bn9349p-Cwm?e_6u?B3nm5ME%=KB{}+Xv znS%c!f&VGEf@G7i*ZaJudk2N-%`Q9SlF{k$oZZauk>-e0rQUh z;1lC+75wK#zn)JUFWP()|DYJ(dcj{J;`x}stNr@3=ofA)_%%uJza;$gPcdErfxkuY zzb5=Zds@1-2>I#bH5n7f&Ze^GV=m68zH|utR|@;p{pb)FXdXr8E1YKdk*-IDe;PzQ zxHuMjJuzPC<8Bjr4@Ff@r9lXCNPbLgc-45mN7$d99}0yZ((}N_0{^h^r#dbtM8ED6 z{Zixn4H3`jc|+!QPGRYGP7vchNsP-X(cgJOe){-2#JHr--)x~beH;_OlOG-u3GWv| z{&OOJo)qz^+Rwb+w$5Rs#iC!*0n3xPX*9o{D2&cOQiXuy}m ztP8~A;b;ok5Dv9@S4P8~R6%FaPyY_DzkP?d)feo5oO<-v>xD&B?~H`u1*KRWZb@*( zNf8^u!Is8&6pU-PUmftry(@ej9jgQJ_HYaHHgMXJ8=`oo=(1loD8TvOf>>?~VRT6gu;SEoQX2gz-#0&zGa9Bqn6gVd=j zo8smEa00`IT1TwDDeiXr+kH`QJn9R^WA*;Jx^=*nZTH23es4Gyhr>GS{p-DTO%>k8 z%lwLjK&Yjo-v7zkuJ^7lLF-Dy%av=I!X2@?#+B=u!cE>fMh319bowLRyt*PBY7Mp} zq5<+1xZNex;T?f!D9{mXZES7q<|2Ic-E}M6bvro_uiOdmhNJb}O@t>x=eoFA_-J|aqFl0&$wOBGiy zLQg^oOxP}WStzi}%ej2q^>v6p#UtF?pP)gl+TeomD@_}}xVzN5fe*14F&RjXGv`wW zIbDjo%DWnArK5wVs36ZST&@x`Ba0l>rW9f1hVDhs))t6+*GE!b;SOnvS7D}O5{0|# z8@rK*)_a@W-gWRR%?Tb;4L*!XJJ~g+gGB_7#gmHiQOry_GT0gE_%Ay(oI5##K8b8h z!qfyDWdPj^;WR(8OPsHi( znZjjF@lwpOM2OZiC0JUN=m~j!7`IN093MCg+PcfuivcXf08$dwj<6Wuv7#(xH;n=& zPRdhawgI7}u2GD3yU|B6`-IOlVS$ctnwrp+wCFC;IAtATP;m@8UNTa*d8dc>IoT%> z&t6}mtG;2oyRHt(Taqze$6ZjyJD{;@q>O=nx>Gq?iJA0vBlo5%*?Z~=AK|fd4eNX| zB1%g~9&)8q?h2JEB0+Hp`J{{%G#&?^VAdu(IhKK`{&Y58Mv1hggRd}6@k*Y=LZghw zWn&8M^mTb-Sh_?e!i4k2v6}5d9&J%#gj9ugk^lIl^CJ8MQ6kWixE9ecj)^ChqGXlZhV9Xoy`#OBldQ7Q0 zSchF&A^;E9Rl-s(y;5;?Q@Ii+q^4eDV#D^5Iy7wJCf6lXLsc*wy$apO zyYSaIyBl{j8O()Ox+JD!=LMbM#H1kZRP?NX-}f*!E*Q*a;3*gU>ibK$t>ah8Tv2Ir z@rsJKh&L(ZH2gV%x2NF;3lur7H2k(}6uAXy_`~9TtEx17bx`5=q~Uu6td^>s$He{H zfi(U<3jE}ff$vGfKO^u5((oq*{%{)p zb%B2{4gaygA4$V!RdaW-6KVL#0)H|MKUd%f)9{r7&qRDB{V(wLG<>7LyVCGm1->K= z-y!g7{HpTR_-s$(SL5?Q8eWahhtu$Ce4b3htMMsc?P7Gv{FN~^K1jSx zlZIF0^Zqov8lNZ9@M?UXO~b44>DuAq7OHlt@##s!tMM60!>jRmC=IX1=aDqL8lMAc zcr`xl9mDNW6ZmS8*Ht+xykDFLs`vq6|KYHU3pC@KXpOt|J=!R27Nx2@QUl z27f|>pRU0_ufe-C_>&s^3=MujgTF|FAJpLUHTbg{{45QgiFr-2Hd}+2HTXFiyj_DA zsex1TH28TMewPM6UxP2u;1_7{B^rE@24AJY7i;jIJ+H~0KEvzvF6P;HByJekf!XKT zb5#DN!ZcLjxYWglW{tzEZF)6o1h*6M^vNMyvn&MDbUuB8!#aX#3ZFj0;SV9Yol@B8 z2RVF(V4BLO4|Dim1XC(IeSpKK2&O50x`)GmA(-5II>O;+2$l)n#^GNROjGxCBZnU+ zn5OLMY7Rd_a3;Ye9R5DRG<8qAIQ%VwDK(z9bNDWTX$qfa9R3o)G<8o8o(E#q=LxnG ze3HYTAvlNN6CA#YU`nZ{k8t=}f@#X0evrdaf@!LrKFr~(38pD}`T&Qw6HHU{bPtEG zB$%e;=?I6{5lpH1^fnG(N-#~$(~TTnPB2Z$)72baOfXHw( zw4K8<38pD`nsIm%!8FxQ4}MJjcM$9%_#}rd1k= z^N(e)XU`=pk$L(ma4L2~|BVnwojFY+hfZwe@p^hPrpkd-e?WU5omqeY`AG))_Xxd! zzh-??L;va%4gGabUw7BfcuE2zwTrsUY>7s9~lV3&HIjAxyiQobC{-{ z{^kcgeTgT~gF|q@kn=8>O=hgJ?GJN$<23hso;{}qJ#+u)>3!VOza`)1+4JI{r}qU< z@74zgzIASB$kW#h0Tow}2YX)_a<)Roz9Y8%MT&xlq2L4*T*4L9q!d{HYXuJv)GG=g zpyE8ah!hxvf~Tm9{mn<9;CU!`7W5(KNsI*bV1;e}cR78`9vm4M_=xua0xE7-72E?E z`;K%)JbgEu9Jmh_oUvVb#8zbZ4jg~&_{6xkZ8>${87Lyt_8ocKX0Q8BqE^8@0$hFX z(IKaq%;@8`!2vfs$hihCLzjDhIplmBzG&!uWgwH3`#&1kgYs4V0gP4O>VXzdSr#9@ zgxS*{7~EX5W$P~oW`N^Ba}y$Z8PW$v*`pcd+WaaSX2Vn>9k0#LlV+pRTbpkOasnTh z+I$!4JC?vI;0p#0l4iIm>gm58Y`wo6uqhZ%@2}!lc>0|$A!{MlzKG=H>3s}-NAN8D zkbIQ@eghgmQU>KP9FvgB;-deMzW^2t=HQry+MD_IEaMsgThqPokgy1=_m18j- zJvY8KNbP!mUVvHd>HQ%sFP`4p^HB8mkHc$i?><^$VC23ml$z1xbN2YYc3>d_1G+CF zs(t&YWq;!(m|mX8A3JO8eM~`p@v(nRl1}V7dCA-pAbstK?MFwXCwlkQf?Hv*{Rh|P zIppadw~tHh=L$T%&r%<6G9xbcdBDEs=k&_r<$W9k?F;0m-ebs7zp8;>f!TMKFpmTC zWsW)K>3wcs@cq$s^(nggen{Q_3Hg!4OoQOweGObGy>g{g0c~bdX`@hTPb!_AQhJ?M zDfO0j@K;cP80Bsg9Xuve2OGIAdgZ#P0$o4ilBt6)RVy952V#{DKEg4)gSMouPdos} z|IGnAhAe%6`-h_M_`n0O8mPk@^$7Xx(Q4`%NVgKHulaD_>iaPx5A@X?s`&{>tma{Q z#X8Y@Y#El5O*!CYM>U;m_>H7*d4FVoj z3_m__2F-p#d&Y*|Q=ZeyUit7*1+@1;Q{r>hB`)rpm)})~@1u(e z!-ubtkp26Xh@R~;QO~%kO6O9&;w=5QE1j!5LHa*O+^NPb0Fxc*pCaO|?nJT+#pHtLYVGZbYhp$^VmtiRftxTSxl;Ovw8ZYM^M{~1qz`Jc!umGZF#cTKuqO@Mug9#7xC0*Fdxq|d_j==JTq*R%!vB#o{>BZNqV58E%X zWZr`N2PBg(EOqf{yy9&dPaeh%RPC?0mKe}v8Nf$xr49f%!P`?(UCA5rp#Ab0>?rT$ zt$xVkv2UMCHCSx^jt@Kwy0AKay{CV4#_xg=nvRjYUb6Hh-1$J^>wH&meBis#CM>;+ zs{IuwhyhJ*1^DQfgr&2Smfp!5a!cQO3znXvRwCJ>)mH%a?%M`~_xzk*`K+Z1Xf@mj zO1fd8y_g#Jk^|~eV!s5jkjQfcT3yB^ws48`$|X_-v^RNsk~mdJ{2Mjq65n3zLO-~n z9zyQ9p@-4F9ifYs-=LO!LL48kVM~oVPiK164}ghwWXgs*?tgU)cU>~aZNd)S)B8M$ znWp+RnPirN`06;`K*=NDBLwa~;Cw~J;Z*Y%V8y^?AxgJL{RX<@B_Z?$iB~NLUNs$fHRHgm(t$C|??V^*5`%rK&-T@w>s|d4 zZMa{82wLn??KBQCSV2pKK!pq!9O#}JJlUgCPtE6G+ zYsMc95l_^=gUqA@l#X1;^vw&IL>IlVHq{)%--(Ks7m@W9$7nkB8J=E<0=+g-geig^rDngNeaXN*=puITYP|L)-sx=~>|OmD+27av zPOn|54E8o=D7Dvm8)XEl(jqNV?GOnSBhv7uZIaf65HCQ855QX|5yY5=t4}~YA_1F{ zzSY3}j!b@s!l@5rLJ?U(f0v?b63s@A!&V;%F_|wX7wkD&fZG!46KTrhnglDY89cX; zGLNh%1%~VU77+#Gv(P8d9EI4ae|E{efZ+55Dw9 zy);<_H&?)0{0Ca3(nxY7hNr5Z4ih_CuKLC(T-;im@X<(O7?e1@8O*O5_}xuX{qRm+ zXzQnjDJaoqieq&{5}yUbQ$iRmH1UCv(atxTn}CJ4G~I$fVJ%-ig=3qzAT@)f8Cr)< z9Uu7JKr)eDFklzJ)MJ+XHVUL{OT!i4WyDDd6&+I`VCK(y7=+lI7|rld#A5GjWg8bd9V8! zpxS_)Q_h#{tHA9lw_ z&{HIWQY3t)d3ehe0yB&yO#)ahkfMA&K%)js3T~JreCU2SPx4dv;#2wbA^+hVgc&BI zsU2Sq7|z2{!1L*x$iM8663xM6+hMkA?H+FPFniN%)!K;x#>GEGtqiBz zTjC9L;UjqXEW5W;`PKtCdVW!j*A>mRH7@>b1KbA`x_oh0M=%s{;RAvre3GB!de?05 zu3lT)+)(GO$HZ%Vy&0!3c2+>|tl-iyNvcM0rFP+dVjjzwKyNpb zz1R#6&Pc*K@|y;hNXuYOlFl0e)=wT{8B=BcnO0hvGp5LlzR!OM>>1NC*fu&jWj&W* zh2BjSg8t|Fzw3ebOs-Sx+!SQ$n^}+PPy?R!fl+y4(8?z8a?p0<6nlO;))A9|=_fU0 zvo?;;(3vuN^fRhnpK#}Hk!G#xo#{ls)e@BztH zsnZu2*p1I!rq@>)dUj8kbdBUHWk-$7s6$M-{`iKh^YGHF+t17Ip$&UyI||8nP8TO{M}k(o^-e$u&(rs@E9|ioHgY4E&ZiWs`@O zL}y2Fw8bW1IUF1`oAz_O#qQ#Oum26WW9p-_hS<~&!Ar{ ze=nM{LDvU1qw!qaKb?9F{U^H4%0Hbn#iDy3tcSOlEab1w&2O2u4dHy98M0sDe$%n{ zZ5W3wdQpB%{)7J&`DX`p2Iz%fskFm4Z<+2Q|HHp?pwd&N)4c*a=T>Fu=NMRzz2TI} zWo1VtmaSW8V6wfzm}TOAG-ch)%Y)42fPIpjb)3WItW~_!8FxY6rY$eu?Be$8WcZnCqPG=+~HI+;I+P8;>JSw{5YRUV;C%ZFy@|&v`ri zn`1UfgwK`dNQBSMejoBTZGnB~$p6-?S2%3TSqT4Z+LD#6+K>LhKD&Jm$7kC_|Ex*+ zIfbskSwo8c?4jql9cN63hsgg{EA$(BHf3c!2R-duvW32nO^^?IHDkGqZ98SknqcVB zKXh5v-~{k7=`B+}*PlIfAFDQ=-E7Uej~&^4cC*F8=~Mne?a6=HO59{ywejQM`~k%u z=7)~_sav&0pS_Tmh?jvOTlFc5AJT8*S^n%`2Ieu%^Nfu5d7QjQ@df{6WB|W=VV*I= zgwF-oGE7DjmK{gK%c8w8qYdWHt;!gh0Kc!QRA4*&dyK~?GhRXc*=#_0|8BOK;5=5c zndT?y&)`o(@>DVQ9M_wXv5Lp%8Jd6R5dZ879-q1l6XNV|Zz%S%7hfm;Vtz30*Zo^; ztOtv5^(hdeDRZ!p4Xt$c!epAooG#<>Y`VaqF8IAj)Ep|rZerQWIeI*0qIYe~$ zPvy_D?*hJ{Dl3b|iDkS?UpL$F9*T&F4&>ePD&yfDNB^1Y0a{s|U zL)nP$(rWTwCAG`WnZRVz6FN>O{ji7f7U*R}AENeq9!Gol2l?-FBzMpED{tob?^k9s z$xVFknGSzU{y|)#U#1KimmU|%xpBcTdX7RTJ&eBoyQ*4yq1`*%hBWM?0TJ@zd*xgtJtl=z_dB>(2{__l9BdmbOAtXJTV z?UjQR|Db2Fg?#+ceSFNN`jjb$=)ua5h5r$3JRVFKSNO3K@d14<%pZ&&`ftj)`TUUH zzc7pZ!{iKQJ)!u1fY1MIZttN@HrUmp-?16_6T>OuckgtTn`6Sd&!#xC$-k})h5x{& zcTCkhKk@u$+P}%>Scv%dY%yUy>)G>jtZ(SwA^6`0xopQ~EAO{sOZE`xa-Bk_@n@zP zJ^BNU*^cL+reKRLdjgeJYW}h!@34%+RaUH{J*Kluv#rFpYKuC5vuy;!f8=N6L3KX9 zr_OKDZ{Gj2bI^bCgX_gX(@CDcsa;QIUb0_keYj-E zB&jfO&+`lNk$q!QzKz|C@T)!rBmR#rIGfS#CH<-vh~K9Xh+lir2TVt5pCcF_NNbP= z(xS#FFw(Ch0(nFb2&B6wib}fjl!7)%bVZaR_1Yth>JTW^Mw;Z>YqbJg(Ec^iATF2* zB;D!l`+%c9rT1Z*U{vmaz<_I{_74C*Qu_|kext@=BekddK4LNQyChV^byD2)srP|o zKO%O#OJxw{4wNKU^^Z#4rc7{_ym=IS>HViMAyw)*j@n)=?-v!dBwcio&D2iy6XCSi zOXAB1YN>5UI+ONk8)@sJ|EYG8cxQdwWXJ zPCQEj&v0;66qQ(t@amC>bTr4BZzuPk@Xinc5* zt-N@N#bU;(n$N?YF2Yk8+Cr{!SJC#W8=3A*;lF#Fve{i)Rk9TlJ6itAq)pQ9Sy6Xs zp=B5T;j@vCMb$WoYZ)8TS>%!$oZ! z;q5*=w`hjDFv`|1v2=!azRcdnA?7T9+!t&q>Rw`rwRh~7W|kICVK-F*N^CER6|#%U z3MWX5W<^Wu*xluYa56(byD&Pt>n*qP`k z>IhF}7cDHDf%{vwVpp&w(8bDH78cHAGs~B(VY+Li*;R$Rq@0CMO8SG6u2@$MeVb>q zDO-22+^SDA+trL+vjb-HE zW%?piW>BkQcZrJ`9F;Cs<3^{J>wde~vfURgis6APu99w@v$Ro{Q$}UCZsJ0eRRye| zbjbl-?xH-F>)ym_0@oD9HnH5YyYwZqqUDpBt0Qu$-fx~2Epr!Qqy8glZlr9suBx=6 z@NTBNl(Ad&`h`q4Rqrgnhb@LLwV$jcVR~Yrh?(*01 zo#of0Vt0jE$HtZ7h+(CUP07%gGX%giRywQI9b)=C8vbc)TS;r#%Bm8HSvN3e*#>6& zluqX?pUx(gCol?y%h;k>t*Bm90bV)5@;eiaY<5NAmk@^sC1eKO{EEdL(m3}QC0nN? zT~t|k5zCY_rZ1E;YVxZv3et5_#@8fch&jq^Qszp%X))9JrE#S} z2{q|iHo0uPw7#{|R}}4#D$6Ph{Y)xm6Dzimu34-Np@C!ErKIo=EWd2wuQS~7qSjw$ z%&LHkCRL8tI~FZBu!yYh*5{WL;!T4VeZ~qyNoBctDk8KnpGkFwofS(g;b_tJALvc_ zn0WtTaF+c*pYfpKqK@Jbd%&LUBm2Ef6$F@(Ho>^b$YN@y=Kg^7<6wj zHjhoL`e6oY8B3)ZrDeY}nKnu}oAa4->oG~%BOO_|*b)uImsoDFSny88Wc?C)wlQvw z*oof^4Ly%~_0vN`v@vKznMdXChlZ+AZhK~ED1!2DC?7`oHp)CKz{~#=bd(!WZbNx3 z${v)rp*)PT>90dWM^N^mJc;sOC}~4d{I{VY7s~Z0t5J5Nv}66d73C2ufPY1K66G0` z&qH7S-yt7-)hK&VZb5k%SWGXQ4caave(A%-n|3h4Qy3t5KdrxeeuqD0@)WyoB~B z8&Tqshy21#5x=Bs*DZze2xFUH`dn9pI0{jqddTOlpPwTG8Hm?1weouz}8OZ`gHJPjsq`ml) z5i8~-UyU_ykNz_2Hr>+}YaUwGSmouk<5qM%gmM7xP2?KjhDkN zfJC1HdmM;Cx0c?Kq7z!Wwy}YG&h+KgP8XZ3^&k1*53rM-0h;kPyrb&4l>4AshA7fQ z?`?ee+~{`P1NtE7+~KN>ttmTj49L!aK8Xxc>CGwnOQ637`Y*I}-6NcV^k-mv`<@>f zLWWMYkEPn@gMK&YUM*dBWwL!O=%+xh8%D2A(px|`{TW{+)6%!4wKL$X*3Su&T z2WC|V^>@9Zhx$u?n+84C5a0LH_}WtTO0{nR-3@w?mL5#e_kw;2=%eMCdq8glo!^?O zV|i(+{ZY`X$DqFidNJsu`9A||&|=Up(%N@bN`5}*%RtA$WU7DdDS9pFmx8`rOTQsS zZvnjn^wILmUeNb~&etNfe`{0i?*Y9F^wH+iQP88HuhQz*E$0F#K3)R-i=dAdpLBHo zn?H^ofArbicR=T#^-%3=RP5vHALt&)$Bogj3kzTI52afWedi2@Q#SS|qvsww`;*Cl zk$g;k$#|=s{laDd>NmD>d>_V+VM3Fv`6!ng>e*ESb{lHhGSoLIuv}?a#@31YGD9N^ zp#DGC|9IekJn-M>0rk0G>T|x-=X$Bn@lsW7yT-+<>T_dMe05O4t8h=70%ME8_m+gG z+@xMS_o{%VJa(}HAcgTueJ&DG4!_jrA<>?dF7-J`Vtdcj=O0-Va`L%H%5ECxQI{wL z^}JSn&XIcjr#|0^=T5My&oxqyNrR%jUC39TW0WIc_4!5W$LQ4O7SZ`PUF!3Sc+eI8Ms0VJ>p}0EUQ`}@U;Wg$pYqkNx*Xjtd2#c zfN{{oujSQBIZY{8qkyLic&mV20`3s-3;}D$k9>r?p<$O`W7=^Yi%&b=WASO@U@Sgu ze2m4XJ}-;nW-LB!JdMStjkB@%wDC6;?vHbvG}y}YAinOd>e~TI}gX=)6UPa__XtOEI#dg9*a*q&&T3hUaibfn*U?* zY4gHZeA;|57N0hcjK!xupG_0N?7H+PAciMj&!N(*2QAM z5=HWTP~5dDSH#6j+|u%^OAyp`MO`md|7@J8@TvGgVYq5%yCA6RsM^2tLyG-}1wWEG z?~ke%-<;#{G2y5W1Y9TV`u|#?{%&5n-NxApX1pk8i?ULbD@D0Ml&zxNDauca@(xkn zE6N{<@|Y-}73Dug`JO0^bA*0T&K6~*C|8PdgD6`?xl@#%7UdnHyjPSz66G;bJ}b(9 zit;^C8ViJeQO*`+r6^a5vicgA!Z^xnwunQ$*f8lufU2J(ki-O3_giW_^0QLN#Ct^i zGK+XOi+N)f6U%HAbdxA$Q3^q3F~Q7YVwpt(FblnAF)z)+05c^cTxMafS#0dgVnb&Z z6V5C)aAvV_GmCzi#Y8fT`C%6G$Se|xB5c z3A`I!UR1K6GQlDDr`(lACFMo#(zy!3Ra)Y%EU7G6#1ESle<@y2ljOu?78$OD4ySeO zK6FvxPycbH;oLYR1*hVFS^5?noAm~udGP2+igXznOF`B@56|nLr){fFHhmTtog{a| z`#PQJ=Wsqg*msa4jn{Fcfu3BPkzokp2Nra);U)M>e;9ljdm<2_|2f7fV=q-9?HQ;x z$ofA~i|-K5DBnjE$#@fFncf8XdBa=t;SxCqFNQNgP?>xRF=KfD>r|DWhiJoDs@vsv zVTa)Zs^`g%La*UNs=MTq5N7y@>IE{LwHnS*y+l3%TMQply-NNWUJd7|UTwx_tMC~J zi2#pTk3cm@9B4E(2-bHO>iL8y7mk}k4199_< z)MKl(3zRN1K8%PrdZpC>dd#H=ctftV8Nf~EMR+xglfsa;$NV6*$&+>i*l)g(`aVOt z2@D6!Z(!IBbEVq=95TO4z&s8dHlHJ4J_qhM>q&GW2OczA2q==u(dJ?Ew@F$tx9y1e zIGN*?_Ce24X7P~;cbJ|7N1owM>ZII2++U$8lm9|K{VH`=mX9Mm4R=v*?HIvQ;EeJE zfHG+?$?U9tR0vB$$+5Sq*j!-03?Q3$_0J&^jIDQ|iqLrh!=N`nkLf7M)?bV%YxQ%(Q71m^SoCJ-@ClF_uoehL$wnebaC=-u<1st6jnu)4WUPp*? zXq2@sgsR;ek1_pIFiC$qx7wcJgf;qqL6kI$2F-Mv8SyFYehS?3yXdLZLylqcf1*p$ zjl?3$FM}xEw2uVJD+s@b@OjJ>2C7l|-cEQzei~Y(@83vCRh|PS(hqJ%U6wB+p$~l? zb-TPBmPkMR3hH_C*YPU-=zhGq;@(-wAKPS9Lb`btisyDzf*TckY>LlK0h8C&+6xqx>e2dcI zKT;<@NBpwV_5jthGOooljjoutyG^PuOfSHqq>Wk?t+J0(pRR# zB1OSh6$RH*=f6gRWcfuBdRP(q0txy$c^4i%i^h4zRXK)q@>Dx30O5^Wn8h@8JhAT*uQSJv*_5of!L{;*KQNEk1H}dKORHaTB z<)2WMOft%Jke*Fajq(C$Gs-_lJ(I%WWl;Dm!*`kFR{_{c5fM2qbSPsz=-GD;z(B`8 zL1B*Fc$FMBsMk5}g9N>Uz5|irz=tG|kLX<&qvI0PO%B@C%8qxyX?ENP0T#zWyk5of_xpfO4nfCA^MzJPOVU z4i}{5Io>xjHqr4B>XRJbgPh5Z7C3o|V-Ms^b=V+(nqx7nn(nw8oG!<9*fzs42Rt(! zcR|iYjvs+1-_ZcfEXR*w+iXV-IOjO%fmH<#dXIdrV<>FRF9(zTIwAiz>-TH`_Q|~9NFM+a7=^b)s7fit#O=2eXV0NI2#?^;M|>i z73A3GuyMt(H2aug5UR)NVOREV3=|=zI|gqWP!p+5+LG!l|uG#3XqShNLv0B_8_>&bC6!ZL*k9{a{%-!;Q;GG+AbMo z363+Jfm^C<=G~~vFCzKdGM|PI8BaX6tQh(%%k-A4Et|yJpT_K#5)+MfjRze78T zOxJ#Zw3A9(E>%tR+n6PGQy9U*`)fBp&9%o70d@=3W%+)v+cSeO$}ayFeX(Z~d!9TI zF0@<8KQ8VcyN!4XxPR<9*kvEz`KP{@(>1QrQeQMOVi$2@*Cs;6T30y24lBVAc z1yc^f$I@-QF`NFwB<6MnN$ z*;PUeRHbWXmzzL8K-y%^>?&2MQ4W?7xB%5}V z#pU^u&+xYX-5j(q$_Y5sD8GW&Su@NqYnG0jsGj`rPuW1IbmwO<31@F5&nO)K1a|h3 zR13<&bI9yD+-&{9!@K8@*#+Ee{lWVI!tA+%`rz(@E|@)!o4o^V=MIsY`8pb+6IIKHZJ@0M;iv{SJM|npo5n$u|Gw9#T!Y|On zq$Rq8h>*fO4BSj;EX+owjw(7-XotMOIFA@*gc0xMlCD!suR-Teb|91y777tSDzbB;ewc0_81` zH1}VSB3-GY0o;b>#p4Cj0(7jTLI4yjv>YKej61)x`@M_>Y(br%RS6GV4~Zo|7G7Kd zB*Ni>2@|U_p_qy3%uRs`kfE%X6{L%H*YJ# z;AiGuC~z`trl8&VFc_~B$SEAz%oz^}T#3S{+gZ)re-*ge6kqXafm;Ksi*=%3n*fxo z7C;Mt>y;LA3}33rmtC`2aad5ppkkW%;lI+qflGRwhgSLzx=MFW$8t2El2%l-97IFu zOYfxE$+)!}?D*A&D?yl@b zWg$MB%NE-~zXMPg=nFavAplnw48^3^?L@uEAdvGpiLp*r^h}oEa8ywdoFWuEU**tn3{CGil#{ugVIw zTd=Q?cIbY_S=Bdcv+p2Qx*7PrhBb$>=DoUCIIH>|ZuVmU=bfOW_bVOUdztmFHbr68 zO2{_ePg$wzbwrKvn^ax&RlLxj^p>=kR!sU^@-k%8U(WZJ41z{~IX_rZhg}{0Ip!=` zf-cctu6xOUf=GYkHZ1W0Lw`=k;x>4O{uV``mHski{gMxn-{^0=d&zz14gEQr7d?Z5 z{wC~^ST)8qgS`uJ;+U!$hj(;Lm43cOTX%6xg)<|~`4c}j(9K?r0TV}2{PaLq-~~pU zN{x7orC)|a2HnC>b2fh3CC2PqI!XaPP~lgs9s{B6EEY(RIjqoiI?#_)vGh<#LLJe z0z8>?;$@UL(3nXlUPc`UHfEAt#ti8J6x%ZC#LH-u9s;$_U`Cs8+L(q_asPI?5=_GHqDmoZQJHGut@bmC>4 zA>9pz1DSN4NbKw3=I`J|Va^S&CI`J|VN&RT^a3-C2 z8H>4XM>6Te%jlL)K+jQ@Cw~CQ@DyIiY#s}QC6{q5ZALgY7g4~^ro_<@4@u={$h>SEM$%-T2k{oVKQrZA zj4HFx{h7%@yD8a1_h+VD+IibqHaUV=tW>eS0v*sv%{he{C=@NZ7FZj#Pm$1w)+0UX zH;wxMVr-vN89<|(SN$#|R@pqjHQWn?olY2d@c$GL@0yM&Ck_3>cf{(o}f z@DU`3P1E^Bm5(RC0cm zWEOBK)sk}-L326HBRQv#%y}GYket88TS4aeoU>7K&LKMsIkZu7-a;A{aL#R#lRjx_ zF5*y&3fS}BL(lJiOGLm7vqi8cusj;y>76Ue4RSCOOX&Z3U;Dm7IIY>RL`?I_EAO6UA3$z02!r8;K?NonLzwa&SoXqR)SR_9zpQr2YR6z_GS*P*ExSjeb~UEjXLKGr2Puszim1vz2jis$Z735=LaNZ6Nfr<&N~UZ zl0y-lvyLp=%%Ql>IiK2X;ZT>(xqvvga_D-U^Haom6^D9s&bvsTmqUAX%3{<>OCoJo zhS+#ID>NT7P!b758%NcL;kA?9jV_ z&06p?z-Fr2vrVs~Zuv3#oo(($m09Q@EZag$rfi`Dwd_o)XEFURscq3&YD?9gtcKID z$Z`nUvQ~c;iygDvfZk=Txd(OGvIBj~TK_H7?Uq}qzJcWAS-wL&8>v3U@;$3AIVM$5%yeuCt0v=qV9S-WWE+-4adnO(H*wp(@+PdBa35zC*5=US?F zVFq9WQj%3d$LxH)&vI`^Rax(|O8Zb(*88loZ=i0s(0OcD`6H<3;R~6lSGaPv`2sn$dOLXRmMh8G%js9N@+{X8Pc7+iSx!;gRpf#KXxsw2EPoH~k@?A_EPokw zeJ?S2-UXBSO6av)b13R2v;{)Un(M#_G0W?~TgP!5(6*b)q3w++1F*JMMSa?t!X(9A;baM`jb9+Y`u%O*8;i*nHX6zbzF%0V;5 zXP!klXr@7QS(Jlj5?R3Km(4+KOGrI<#X&Pw&ElZ>7ho0Ip8)#5LpzB~*G_K(iGyaU zn#Do08&S&pYd8OnYgZ1MsV-ZTgXYyR%5G5(nu$Hnq8v1ne_T9o*lom9!2M&-c?$JH z^mi51h=b-6sG7w=^WFcRMq>Y@8tDN9;-GmsnwbsAIWDW^Ez+bKx@ps3V}{fCOxgeKPvF}%Hx#N0$&Aw2m$Y8oJ8)%>pI=_c-^S` z6kdJCgFoYEgXr8s-o(L@Z;Bf|jBNaq4T(o-WeQs6@(Pm8I3XYEaAe|?=1f#{j5lzZ6N;ou zCMvxmiYv2xB3Y1!$NMF_Ibx&3=SIv-$<<*bF6zBW!T{aAe4-m|^FMPFPEGO-F2_f&W?d-a z4n@T5l$|7EPRbq~+7)O(Q0JyhC+2w?5X|$ZO77fsQuBn3nVSq`eW8K5bBS?*Vi;Lf zlnDzRCL$LD%W}{Lxm9H#yjuaNTAFk|ckQswmt{f~4nE6;k_ujd9hDYfa8OEg5>h41 zMCe^Ik%D4T5u-}Tstg(qYEuXty`=yO8cf~)&7fC<)u;w5k_}A*9GNTAz&v~!ScXr7 z%;D1@D>V(WQ$cD~g49MB>MI34p8=mF@VR;e#U(X$YV=`RjMq+!37}D!!i6*?^OD1o zNfAG6SSE^q0xJ#uB<;vf)`a8~m4K9#K0wnh7=rtdv~=tih56;IZYtwm_^HkLdQd z7boJuj#x3CXI@-XME|LUstXS<*DCox7FLW+Ss)tp1xLL;y=mG>E4Tc~xOpztHPdWT&qK95`78ES^aY7^@6m<)P#X=nw4VoREd5 zhQ|_-l={|=urEGbb08WGN2yz2@4%zgwbWo|s;O@~9OF|h#$u&Y-yhb0EknwEU!QfU zJ}x`-S*`l`O_%DkUXs5qH*9Lp(CH6fe<>EDllmfFkMsIcUO%9z6VECAM)^U}>UQ4h zRo?3M>#5bNdTMq1_0&qOQ>)iCtv_Z@w4k^Zxi{Dl6?Hx%h#*2OQ?-*&?p-GYgmHb1#!nH!zT)y*H@rhisf zr2pm(a{P7uUv=_Q9X1HkQ-~2AyJy6yx+@&r5ksH{csOHN0v*MOxZ+sUKWx5<=>GR+ z?1ht5Gx_;!{6C#2|E-fwEA0QVG?ALw>Mtc=b}JKFnV1-+CUk0o zD-*sc4jVcZamo3;4o|@er;uYM0W~ebWYq!Q9r!7M0GUWD2qv()>DQYj`Qk49wM*My z4lKK3*%IB%NxE?eXys=J$PXc3XTTd{UL`p&Jm$S67N=as6dt68gg@?0gz&61;)~Hw zGHg$@qTek({woCyzC_61zB1SmX!3_6ftIF3w3T`5*Lva19o~3~u|9M1@==4Xr zYlBfFNeC5s0$r4lVkz#%KpLbaMZ*9u{T@cr2#+t?vI`IX zZ;E5d;bx_1HOk}M*0!z?kN#&ZzPOJb?v~;ao$v)a5>X9$P53hI+4@c_V=Kea+Q81B zUqe@#txd$&wyq1r!igyCWwAhq#yz6fD%pd9?$AhRjD}m`x~S+R?2pFL$xvXI`oj?9 z%3aZ5JTSb+P5gHb*7CKcsk?J~xMNK?zA~K9dZjTM3`d7|O+5CF1{#l8OT+`QU4dAf zd0RVtZ5r=GR%0OA8H{sd5}jV<(Qd;zHU;AKoso_}C!UH2o5fPD;i-uPS1K-D?u#L! zI(<<@YK-~RiG~rOUqN7DFCM@rBB6yAY%h&$YIy2H!FUkCbFGg;CT)C`4z5Sch7)nt z*bTCGt>2%B;-Pv7Sl`Y7ArX6C3<73%K$+Fd@AJ0@>gfk3l3|3{3`e^~9-!cC4My?n z1FgY8M+<(xgPseQGW5#E>*a6Z+qD+Ec)1hDlL_e#Oh$wK^Qq0b(=}n?#t#vxz7)x1ZQAId7wc#Z=9?*RBpU2Y2HXXv zi*%U6uMTzvS`^dkx&nUO1=6Y?>GpQD1pJum-gsw(bp|>q90~ZMe-0P@YfkmS)|??2GtX+)7cZ6lF?Lt`rrT1VS4k1T4?kt*NERi$|Oy z<$BZOwr<6W=8!*(wFZwkrJS5JWX(?8vhNs$Sl`hRX!CW{Sf0fz?DeJ6uc~E-H z0|K+J0WJxUUo;DdI%zRV$%PUw5sO|EvbwtBAqDWovk6ZKZI6aS!xmH?HCQV6%EJ49 z!J>~j*4WK|E6ZCGQ+`p4QL4fnEYfg{-vnP94$*>}%v@A~oBi!6*Jx5_LlB#c6h-Yy zZ7`X*+FVbrKO20}AUT0AK(s$gHD41}Q$ccPftXF^ z%w!CTyRx|KY*9EP<4SoUC1Rgd4>^y@_t7)d{F9;*8%*q`Hr6wKh}( zZ|@8sVCWu!n?oBOCLZ35I~pwiVzyESTv^{xC!|uuVurzxveFUkX!NHvt&LDIatM(kus#L- zL2R;X`2kX@nOL1x1`tK+P9sJ)XQ>r}mOtee=DcJxMju;t+-Z50Vzu()a~f^fCkI=E z;N{p((h7?xMyM!T2<`rX=aPD)zfSzX7d;?bF;Lyr2RbA1?iIAl#!gOI{F90hebIO# zLRM2W(Q=?!4ZJjR7@ANmcJ7kD;bpP*>8Ew8UY`@xiBl)5^eiu{(o-U1G$; z5kGbj+Ob}Z1Vc~G4z!4{!wv=@-O8l=E3&l8fqCqs4G+Ip!a@RvDATY;y`O=)L==1c zjzp(sJ`76}YEUFSu>wgs8gCBa0FOI6Nk}bseECf-b=*0X<>(D=%M-Cc3rs=3>7JOc z@EBr*nwQotO;?ng?^Q^L?LmJ`9iq73FM>)*Z~TrC_gaBi>h6Vhs2zdzVI|);V!GpL z=;09V4_nvK%>(Nw<%8TrchvC7x;3km+`@0c=w~1)ang2CDO>oB4JIz;7HJZ9I%{!j z+Tn|^U~Dxu{lQg{#PTri>S^GyL&EP`Dy=(xT_QS5Ya4vseDMcv6_N`#fZRu(ON|Ld zj-oThI(;GB$%-DOi3B$jq=BFN#1MU~9kSM-n>zzF@o;C*pYjV$ z=vEdF$9)~E_=C?Ol_`fm%3Z$V{`3$Lhfp}P>E;0$#fbp-*Xnp%1V6Dy<|_AViY#@g zIyqS!^(a4XNBvQ~;jR@ERJl#_(isPaA8VbzebtIug1{^`XJE!@NrXErC8D&J(NxBv z0MbGL>{lz^5RE`i@w#hQ2P4=#^9XC+P?K`^jzA!ybRZlO5uj|wVq~D=S$?9%uzJ%1 zi8Ba|;Idl9rRX-_?NOQzv>^#&N25g0Fy~^LKt>2auA@z?{XY+inA-tK`F!bH`$KQspW~-6~Pw# z+GDEgD-zoS6e)yJ<`twWBS9&Y@}GJ-Mzc}TN8L;5M1Y_(v{}Lm8pM*TW^G!Xz{wND zFlS)GH;w3N$`6VP%0L(NQ|nR|S55%9;?&U44u+@SR2SW~4R9z{^kIGEc|~kcxJ&7z zSaBj|K3J0zOO3)P{Uk08Zc22iI?+=6szY&>hGP)ArxJ%>>QE?W(rV(+MuV6DlwgyF zDRDsA3`cC<7*3yPqKd#w8G=5Fbc>KtX7upD@h6moH9`-C#i{^`)F%9? z#JY;#u1)zT#*}-H3uZOg5n|xwCX%bfAf?6!6pV3wD6Y+fseWMDP{zuuoXpetQHq*o zDOtytD`-RrV$oQUoPeF$WolJ4oQQzQ?+ao3n_9Y&dBnMJDzqb*&$O|}1f|nP<$wlJ ztZ0hyWBstQ8hYcHF|l?v#`x^X`ShHHi8-D!CVE7v5*934up>j)Xy;{{a zT>l9gUOrO8%RfOwUwT6$<6jQFpea7c!!LaDj$i1dTD9RF5V}V0rP@$^tQUHzRyQc^ z@McM~TGh(Bu;cywZ577oJGyj9%%@iAJ2Q0Y8NR@%R8y}zMfDq^lvv|)qH0WvYOE5~ zwiGHQLa99`NPkVSsMR-2fldMVftq1O=OFrPR{f!UpwQeHTd3($eL4g}o6`!UJmc z*(9ndy;mc+a+l!#T(VW8TD>)iTBlZ@NTN2V)s(tMRo(kZu12-0`c-1;v`+TuHo^Uk zRI3j~HA{>JdZ$)ZL3)O7kSAq`iYiLA4cb&uYP%5(P!*?IT`-AMQmV5_->M2m@U3dz z98p11Q>$G`)K<01e`o^ek#nXht2Ehgy;{{ayf8st*zj_-;i{yp4Qf>@YxKoJ6@X-` zR@H_Wm!DlQF8hR{n?-qxC=ZH~p3*|sSCoQ%U6g8C6JWCVr>N2Q*ywswDcBiNek98C zqD)U-0-Y>Yi9Av-%0^K(iE@i5y`oG{QAt6fLJv-&YoaLAXFYujmo7CZ6)5$p#<3ci z^pPjJM&qaNKGLOzrz&4g(sX(oOKd2}us)}eug@{T~B`Ac7s*x(8h#&|8Q9ykCW_IT8-QGT@ zVkLXu`@Naj-PzfXyEn7fieGN@+{#w`3Zv&;w&HI#dTwSbex=d#HCyqwm=|x4BJR2q z^Zmsjew7*D9-`l1jtB9pjh<5)7EMFcbRj? zLiqJ&cRqyQVD$Xd=+jQ~HlydJw&FLMjkDcRh_5@%O-7ff=)+F9yg#!TqQBX!RYLeC zc=?3z%_ekyWhYK9KUEFUZ!v2@{2eBgI?X#nFos6EY$EJ5x5UtIjlpk?!EcMf+l`Qh z+hyj@|MeL*0O&C7{Q|FIjK+5Rq+K-OYo6UE1ozLCA7S}Ted@5M^{*pfCm$9$$#>x* zl0Jp&4*W`!Z*SiO9%|QjfOGvt&gCNOhl2a3&HNmAhuLiOT!xKO(U%$DV)RspbGWBO z>q1AwZpRrlhSmkb_2ht6e^uH1OVZkv| zaC#H3d+qb&)xbL<^8?)QInfD@RL`G! z-)l$<{T)y^$^V|n&j>yxxc;sKA`v;EyMlJI2Ko-uWd`y>C>fo+7n%p?ame1DV*1Ty zRpv>xt6xcdmgHlP4&zsZ-k*nm&v^Sh{}S7#P_vZiY!1c=j zN9q0#0^bUK{_`$(zfB&#PjLK>DJKe-ptJ(K3-nKl{rt$m=1Js)tIwrwQXh>e_mvo& ze%q*9WVU2iIQiF8{1p=Y1{w6sCtu8b7#L&;j;B*R0Nd6~9{wC>P z-PKcebX+_y zcwNe+^@-AD&>z*OTkvfT#wmT_ayJ2|cKOFHZ4)_bQvdrz&HBORt{F=~zLgdpviPEDn^iRd$&jasf&ene~i+sO->Guvo^|=8PR|wx0gVQ-- zA^IWUA-x?J+;8s}1Rs%pR6RTrBmapQ{ArQ%JCRcqb-WZq|JxY+Pa?;ke{RCYH`Lzk zz^T2XGC%Z6xml*)V$RBXt-bRs)~S%3qax>Zk#mPI+%NcJg6sHtN^pPNosn|=`Q#;` zKP}_&8j+9CQ?CDUPyYypV>~DGr_$dg_?Kmz%JOFB1^4^$B=AsszbN!+8P_|cK4%60 ziPTf|@Q)ZdSD|90|1(k_)z2vKP`O8A@c9`0W5BzmZqe*3G4ziBr}|W-U3-P;4Disr z^qSD0mHyTBj?M=lIsW|C3p~`W_W}>q^Qg%2*E>3Dk>va9+QWkT_V5_+P`OV454G!z z$azxqAm(Mx$H?h`aNT=H^}Gdm7k;$Y|Ni7wrr%)v@ow^n3#q{e3h&dcy?c1Vj%Biw z*1~NBZ}r*#6CR`%FUHH{xM>R&30ANL@=3J06*%qVrT#(@E(D2PI|s?>Ge87Su5t-+ z2-RF2?n5=Whs;zdIHs_&xL5~E{d_@rF~R|`QsK)|iyT5*Ru z2O4tJ1c9*Ba@8iAQ&WTXWT`eM<&cV;2HAy&)dO41)!fTsa)pARsop*cF`(ci)M{ng zl0wK2#kmNSX2xg6>+XNL7wlkh3UdyknS4}Xla{NNVr{UZ%e7LiJ|TmR0t_f{!gU_n z@CFDYDja}mEZ0gFiDau(_z&5gNpb}b8m-;s8?A-0rfjKX3j>4w{R7i^QfMFQLLNn> zJX>!wWXQr&IR-<#t!=VYGIrnC;k|ptzyghB;>*6ofU%yh^- zU^fYCXIEG45+WulWjGnu>h=VD+~KxB=8kZ?ign}2*pYh=?Kzkk1`4-lo8B*y_m4~f znmjnHWk|gbkB(;3lXh~?-mx_G*`aJ@VL3fMI+3kpEu393vIY=#0W+=CGvp0EX|pLN z97LVUD>lEnn(C!cGagsu!kww7hf`@%>F~ZbgSm_C1 zz0-)d%Ud{8krQ7AbxzuJwx8-!SfBxznLLQ@(NTh?(riA-4)y9z)$q&;`gfr9>oqEs zEI1ET=si7NZ-y^K<7Mm=Tx8)P8;BJnU8XS35v#Xg%QgpfF4oi0B4K&(3WisQEzM+( zF2k`a1*o)am*Je2t7axsHVxBE@sd6dlL5Lf+B6GLrNy>v?! zBDL;u23G_7JzS(?mvWnE2@CIVPa0KB`j&?&i|tNr#Z|ebrzX%a>MgQuY7lG_lB_r+ zM;%>>BBnB6T9opO>=hY}Mxu`GL$n#qqU-CqhlfSBwy>Nb1zp<8^Uzy%ryW0learf? zM|jB5{sWzb`707KFf_DpEVFmm_9Xg9N?)P0*oy|u&(E_`{0>hI*n`eUX-(nzuSl)0 z2b@FKQCVsi#2_{YqXqS;RN=5hhBS5Pzq#IAhdObfR9R+Y>dT-BtQuZjDNtdZDvwbAw1u6lV-;K(vdRdPM%k@XPOE9Vo@-gj zBEySuYK6GjW7b`yFlzFBr?uh|RzWSIrn{xS8M8xP{Cm96GmP74*ekKQ-O{=`b5nin z$no0hMnGdElDgx93EAa7T;X9e6*nD=v-_oxS_&4Hpn;!oO4Wa1v1PNuQMWO?wUWxkCqr5B}m zYa&&OXIbrNZ!F5r0438WgrFA2rc>#33L9qkv_&~s^|HNgv2)sK-Jar_grQ3?y|5n%`$T3N!tLA)BGJY=1ZgvYh+NE^=H_U;pi z9Cx2IhvC7yOdm6+$|re3Tz5WfSkL140c>)x-^y9H@e9m*7;LgvqmQf^)+D4;;IQo9 zcmvlf3$Hh-+#)A)D-A2Rvv)hI;J#`-6KpK%ynOSb>y~e|4_<}UUfd)I(;Am zah69#0&|o};QJDHS13-e%tC6ejANX@!?z_mGeNF%)6>=B3B5zaYf-PEXT5~Wv|fs& z=odo&=QVw=j8{B(C+d>=6KQ^%;F|I4M7=?tz~A5So3_fYen*-=E)VcJmJ?o=v?Tie z3tufa%Gcld)%+sfPf((ANtE($BoJu`eD<+5>WJRpn%=+AZ}uv``a5a< zOQF~LE1l*?@SJ`FSnt&@O7n5y_vKyC}c< zcWJJ4!q%w2-hbNTS3fY#2h}k`7<_r3_xROcOmi_mEsk~FxWUDjgkPJfer1}gKcVud z{`LM5kN@nDd!jkM7H&yC|F`gz^rz*YA9CcH58UkT^}o;meLRTrt3R9OPt(Il^85eC zcoyYXzcZ1Bnf5iudU&BhY*lxX$e3z7;^l;_Z_kj8s z@7}+NV7n!@q+jW~2*SU9SIq{$nxx8^7u}R@HDsfX`ow;eX&^ z$3VXW8%;j{itzjT+wgVA_1sNS?q>T{&MDz78Gn-Zk@c;+XV+ z$Kc(SfU`kK3Y$Ybzsxj%L8j`A-(>+bf;OT_KCJ%&FWH)_|kKB?_G4)_1` OFI>J`2f94;%l{v05Dvru literal 61672 zcmeFadtg-6wLiYkOp-Y>N#?}>0YOH}BPx$1K#UJ02?8QeC}u^>g4c^# zF6T{8kVe$LyGfu_$(WZTNJj?#&NXrnrI%M!*_S2o%q~mW&IFL!^|c6mUyGMlR5?h3 zaj8-lAWK6@f6qyJayditsgii$Adf6G_avYmgOv~^Jw|Du*N@t21`@(YR5 zx=Qz^nM|wG++9F*PiLm--s0&P-Y&LZ*O`|Ur)|Ex*v9l?C%e1M`t_A%B%2qHU5_1uNZ%&_$$NTa{T%5SAoB4@OLf#R^V?X z{;Kdt*BboQ;BP(tHsJ3%{MF&lkG}x^)U_Fvdi+s1{budJw1UO+{%ijwM=K|8e&oFC z{Hnp}KZz{+<1hYX|BsvYKKFj+Lw`E@;?}1+58k=B;%~qG@Q#wlfBlK8$7kgqJGS+$ zwc6JvcU^S6Hu_F$$GeZ5e|Y*WH~sv{hc4JU^!K9hhwuGz-@53sAMaT3)DtIGn_qbU zh8O2eUGc`c#z)SNt3Nz3cd%kj@P)`S_jhla|I6#Y_?L%%@zqyH< zw$%22G>RWy7{w14jiUD_qxh#`6g-e{B@KnWNahdKA4G zqsTcjikyEN#hyi@$jKXJTPPQo666dU}vg0T#dyw z6+h)yZ?bT}za6DtvtVZ``MIOmLwR?43i+*&?`BynaD^aVCVASq{4DlmO8B^*6a}lt zA~+rVcP|zQmB98u4&h5_alkcM6s$n<=h0$;t5y`O4t^m1MkxpG;@1Scx>+`xQz{X% z_y`Lz@gKQbAk;SEA@rB<-z*V$T7&4SlKdUgo~;7S@}%A;rJRc;{;WmFd7@Y#l>Byp z4WXeA7aD`=uOO_vm_A_V=jlFRh_;-J%IOr4r#nzNYI%Y0pmS2j#c_kaFIW z_!|W~`?mCRU6P-dOF!Ho{XlCrT|Vd`JDtTGoG$e~Bk>0$UfDBE%1@5Zdw9R5jPTC^8PCb{bdHph9B;2nd~*CeDdjAa@#&Rz z=1M!0=PBi2H+IZ@vn8V}Y_OBY_s`PLD*l<@zojMI>W{_(k(l4l{GrxRjQJZ;Fn>kO z3V%Z|65JAs#)6TW6-%4Lt-+eW=H{TFrKb4nI|C#j&>Y$c#%ntKYovsw&4Fk%7-g+3 zQGb1VLx5H7D2Z(G*S59=>bKRjw?S@8uq7Idfv~JO9EkZ#qGjQB(pR;kyd%);uMTts zYnmd#K!d`p2}Wb#NCH_IZr$Qv774ddg_t4{|El`>_DCeyfXFAX#|uL#DP!jN3G!(SEz z9Ij{35eu>!-%@n3CfFJcNBj+eSU_SbT4P3}@`b-X+|t&LcK+*DE^G+3ELd7lzIE%? z1eni3a@+D?4800Rs$-E5`slx|I<~Mr+>T*GtvOmz9m~(JZwf^Gu}B~ki&oT^m#+bC z!RA0TRPPT*WAI-~MSYFGyn2zp>e_lCA=ui`Tv7kewXN~j-gEfCWhpjTmBh?`Ot>n#AGl&&YVvTaV zSUia+AH~eLBSS51&Hu1d!@1)#=%0~|Ntl>`qYPmFWpG+OvP+D@IvfdX3G%tP5?Lj# zdf15bnH?YT)J*vcAhki{R!A4`AF{#K>XD z)?8a7hpzy`M=8`ezH)fSim`;%GzOS92|vlX282jlqnMnZj~>doCp|V+P~_*0@CJID zm#VM4r_=}4(RfE>2>S!=ofVav^UKSju^}GT<-FeuxYc8sB6^#jNXsHj{$abKL~pCE zr8LvftnzO`LF!=>R^~5KR5_ZWhsj+W(`FvY!sctoVk~M2bo!%MDCE3Hc>7~mJGLWh zHHh&d(_6PwJXXgFd2(tM2Jxg|a5|p>e#BxhB61#fCNwSb{VNkVtjPHb2&5G3kL_p+ zmRA>$FTt4SA0EEt#@v$c_Xk^PU*-=rR;-U=X8^(eP}Co-4>SiN6^QV17>^xPd$1f@ z3egcRy-);3^+GX%q^81PV&&$%ax|>wCYQ(OX;CN~<*0?Us3q3z;dn6-`EC%?wiDaR z=FsLX_4WSfyl8k{K0$48C-!m#=Mh{_wL<0(^8J$Ezd4F7(9RU7)&@4eDclmA-yCYc zaohY*YkhNjLvVheHBcXJZ3rv?eluIXbg6#oq?n2GgBI>GIeL%2gT zvzH~#6AEQB@VqAZ)%zN_E#p^}x&hka<*>qMUn%H%68N%-QB;P)lryCkeiW#`&bVdsG){sxIZl!U)g;*TWZcT0R<68?6HKbeHTU*byz**KD(0eDn1V<;Z=N|Ov0=9JeP!5@#)<*+)fprz9hVg&$cAIiqC^d zcom<0Nq7~X{YiKgpU&pt_Ne$QO2Vu7+?0e@@wq< zlyQ}tgjexdm4sLE*_nh_@u~8zl3yhA$>AjaLvw`zk0s#`Nc<+5*OeRvAC~8c3g1*F zQ%z&pgR$YAtygI8S+H(fHO);Z9X~1V0@UIx~E(89Q0YA}z?>FF$ zM{I)z{G|r|a|XOT0_N0%(hoS!WEUCubK1Nd!tox~?!@Ia;8!NlEZ2a~H{kOOczLAD zsYM37*}z|Hz{?|MPW2h^I7*FQRR(-r9Esc-6PGT>EA5UtICS7+~p z?=;}+2_dg81Kz5TDEAxi>OC4FA28rE4g3cU_*Dk{Ap<_!fIn=&+YR_520VQpKwXa+ z@GBG&WuF1>FyNmv;EfyDlLma1f&Uc)p3Z{Rb;^KuDzXfUh#(uQ%Y=8}L&M_)P}Kkx!xPV|vZ3B$Mmk>-TZD8;t>i=|t zy#$})@MMB%t2A(u!)}5pRSfiT*hVm=f`KC(HW5rIVBipk|F#S;P5prb9Da}BSp;`+ z_>Tn7Cb*5mrwOL1Kd_0zuM&JQ!Brf7kzksl1H~MEo?zPg4dik7DS~N=4R|?xlwg`# z15OTqhhUmI1B}C8Cz!T~1B2)J_!FE*@F@=8M{qvDCpr8Xf(r=l4&O>J zZ5aj*ad;=eiwHiz;RwNn1b1uRExQyUK9R6E5VA`?_9N_SK1TQ1Fi^G2;csaps96n93 zkKj!lzGA7DH69q6xki?oc?mkde7)%m0q5&o{2uhy`Yt}_>wd$x=bU}J>H4RU`2Jif z65o5*51pd?2L2y|5&TaX_>Y}4`?{a<9sA=FpLWvspXb_nTNlj(%ioVL;@*~y0Ti!kZWP`6KZ6?htUw3(bexI+m{FJY|Y=(}?Nndx` zjQqa-`3Q)8eU80fM!NU))^_=N+K-@TU1eAy#($dJh9zXVWB(pbuevb*1K*z0gT9Mj zBIoti&6wuf^V*=V`}e-?>%003FnYe8S_oLQ1Ok8_8ov@UpkRNgP;dYW`k-JoS8#Dc z!SsKu;6VR>!V^#c0gKKcCb)ukFbJgJ57f`z+Cxxq5(=IKeQ5l1Aj%#bJv$dEepMcQb{;VtCZo{q)fI z^W=gaZV-CCtLuG-Q*iv?+|W=-_wk|er-hUHC;xS5sG|OS|8!`7>%#U&3w+(r#Mb$G$1mh^7Y$(X z^K~DC{}Do0p*ye&`c{MWMPGLWqkE8ubMb9jUx^7?mkW{SZ*$BQ;z|FmNo zwkDTq?K(L6H-m^C3QA*q{&fF|M{WO7)%L9~C1yk8fs%D4YfEZNYAU+VV`}`8`kUkH znflSy=v9v$zAT%8$$DjF&y9Lz&&B=Mb17H)y5FtnKGE<0kc- z8k&WJ6f@mV)FSp z_HqTj?q5-#8nDIc-sc1Ro+s#)#qxVN2-?HsrS4~uv7T5AKLYc{2f*}vhV@! z849u!{a-=ffI7rcN6BMP7E8B%nn=hbJu40)yB+8$KUnfO^||CRdc|_k{cQhN(W`xZ z?el#-_i#V-e2+q@hsRY954P@oIxv(=sO)~B|Fh)r-hG{b$bcI1!in;eBr_gA+{yKW zzTRHW)?0fLHXb4N?~xl5t!($P!<69>yx?l43e36?50Z$6UPxLQ=qaQZ` zs_Z`P>;4@HK9AmZ@2i1Td!C?IK6X?A%}F-$v72?J7`v4afUx}V3Ih4q&3T_2cBSmr zE^^)p-b>N5M3*>A?>(Ytv?QMB|2-+_-KQEmd9PHYO_7mSell+VZc^6$Y8;*qbK-6| zN(ve4o94UxI--WUs?w#H$ty}ma zkuQ46yL{SHLSeUwhCbfYeGuJq583PZ);+?fFZzz1Hq&;hyL^8SH?@0TF&N%j+QZA? zwv}<)^qzZ&#aI8LuXo`usq2XJ{XXqIUys{oecspY+{4>yLd2Ckq;CG!9_|_-$$%?) zhIHKiQ{3Ieov%_}PkWcIXJ0PZ;%VqUI35nThdbaF?f?(jVCeVAMnN<}fZV|c?P+Yl zblhPgKYp=D1mZJiAwfj&QL6SX`ZI1xDW?7%;FF)Fo&or|h}Y%36(6IU2eE7TH*!Yr z_joAw?4yN3`l<6$*~<{F+K@Ks3CqVc7SIZElT`g>bQDvy zG9mL8$b>ka70|@Q#Wiqo^vcCi1+)oqadV`&8X@kZLh?U1v4F(w+115pcaF$Kvlqx< zJ|9l>f0l+$X0O{&f2)prD4qa6!H4!0YF4C1Ii3kJsDXz!5SgN!5V(hck3~XUm}vf2 zGWM3^wEFYSS<)_HCvunAC18&h1knE*bP}H0fI6wa937Did){^?_7^AmSE18C7Q2o; zZ+p9UoyXpRb{_46*mw2Al=DZSls&29<^l9y#ZCG^7f9ea$8Q4`M6T zv*LVr`RiD#%3sGqweuZAr}Gl-NH5{yssAVXBYY7@owm0yj_-5HN?xI^pprI&O0{~z z=?IAIb=U`CZ(Bu0&!Q(5dU>b!89j}?^Wwdjvi(1L7frg;kI}CTeeYSLvw(_ujXac0;pFwipT;Tg^IT((~RV}6a7yC;p>K! z6a8CwYB-*YTMn9x;wFJKNmdIV*QbOspDs%Hh3mV5h?222S;_SYB_^RH2TBgar#v5U z3K2LP<1SXngilA*lDzZDF}y=2ksCxDm2oR;PYFwTXx;Kwl1B!CkRGWe_C2F`q^B4| zB)!3W7e9qvgHN8AaHYaQ!aL{50n$4Mk`?YwD14np4YyEn?;wHkxvY|xjE9@KLytkE zbQ(HI>Fq@SdnAmbt9a!35N&ei$Xl>@>?KJaHsLN9pimSeq`WtlW z(8K+P*)_aPH>M3wtYGHid4uhLG&B&?aij~Lg6aRbe_YZ?Z*p5F3tLwV@>NM1do9Gi zmCo;7;?jrP+*8iS`@uI2`ja?h_Y*x@l;{x!1A3D*3rC9$a`}n=MtIP7W%;1vGuRd4 zO_Q}E)-W=su*je2|5QT!h`1eLiH~j46MWG0x?d!%P0EV zc@)bulgOAo-wh? zrz`UOv?32{1P%gixR=QPVBkKe&VTW(zhG9-drf=9TTANeHH?47$6w#r7{Vu4>$lOz zNmt<;Ii)*d!D{hQbqR?t=g^mR@D-W_iJ$}t-^m!>a;d}&V@Z+#mJw3K*P9G#z$9?P zB;iX#!+GN0B9h-KqAw{8=OD~58P!era?@}gjvCGs_XYJRPD(a2$wdBTt%PU}#@i0F z-Dvl4n}^w(WUJ9mp7_M~)WmS+`}6$4PJC(^-^KB_h;MCysq05eYs*T!{F_qPkXYA5?U1Fuj-vz9CJ9?b2w9^%fvLT80CHm6OJwmKAp2zRQc<8L)}>2 zEuLGlz#@?*eB-#vz;KG*(ZjV#e&}Oy_F~vkgiq)eGaG#ZXkN4l-!+K^HlwD>9W4Up zr9ax#+R(}7wRX%4wKj&?JbczVHZNr#70>9@D55;rFghI{wZ`YMTVnV@kg7(+uH)MCbUiY zB{8KC-#bL~ci>BZ3l=KB{cfZkSosSxAk-wf(D|K@OKFzWXg6!BP5BRR@2`P%{! ze1mS(YdI)p#y1|rc)B^w@sSEUO?o}}-^ zlrUrVC0_+VxSa`mx}*tdpU{~U!P4A@I=-kL$Ad?T=REN`c;a>ND6J$XUI$OSZqs=W zi?tkPo|MDVCgKnSmzkc7FnCcMHj&>9utr)2U2!^Z1lWAR5KEh?^XDo&2V~k5oze3| z4uU=H!Zfytjwo5z60G67sY1}duK&9p_`u>l&CX9jroN4JSq@e*whp86+@PIJtUf25rnGCewtWm=#Y?P=xgy5R7j z#lBAVpW07ja`}7Bk`1~!xDkyn#-}t-zfJamZnD!yQ`i)n=|iv{scex=e0f1b5GNdAX^XG6TN$YgpGc3xbR zWuBeRx}24#EnYi2uCZ*>W$8?JR%T>bxF0Q9xAF2W=5@n9P0u>PVQbcMUYattL*9nE zH*WKC`_1~l0l&U3(`4yd!qykr&7wSO>Eim6?as`66YZPoKCnE+$0y4s?55J0;VtxJ z&F1#zGp~*8%ko(80G7%>**&-M(&<^w%P%tTdDHO+nA>xL!`T@p5T~2!9F{lXzfE;# zmv?>agnwODi$?fy`fQEx+1VdL{)Rf(cb@!j&w7)?4%cPy&xX3JY-Kt*O^s>_!8KC(bQ=*5iT?cGhM zEm;%OyUdSXn>9EQd`vrQnIYnL=wVizac-kM>tWWn``kvGjnk+6f!f2qtZWfC*>+?6 z)NlN&g?-HajQApdnwHm@voGT%f~dpwPfPod#|fXG@K0JA z@VhU|$w;%D$D0pnmJAD)7kA|w6u+=PBW(-XUtE+nG!cGZUMOHE{QE4APnNNc`m-?| z<>B3IBf&W=Z{r^H3J`(=z^L zN0+&&&@)cZEuNPh%-dA>wj5sZSO8+_-`Ukq(Y3Uj=|1^){ zm`d(H_-7~^@m)|%{wt(**{+F9w>)R!bkYxdC~twjfapWie$P{A5C0(l-AQuye5dd> zj{i0`@rTT;pVXxI}zVe3E}%JieWE zXwT!rlJzG1vAJ-N;ve)Zb{QXkbRVCLDL!p+5j|A+k@P=;jmLup;|f0(B0iwci}{1` zL;o$V+ddvL*I$-J{$Y9=1t-zZS|0hh7~`MK?LD}`0lT`)+cqM9VmM{|?w!WQxhz;; z*%Ws+`PZ8!_z!IOv!$5lC!YT-`!_h;mm&Urbr!5=U3;Fu`iA};g#R6o%eHN_^M1SQ zvWGy|%LSdrpII*IG9ReQcE1cYxpj{0iBuM;{AEYpVQGho>{v&;Ea$GuwiDm-IyHZ@ z9R$OF6TeQnTkisx@?*Oi$QZ{n*`%Umo%zbVw8 zwrmiS%mk9|NGu6TFH+mfKL0T;(4{R_8JCn?%W%+N5S3U|O7NO~ZlS4x% zQP2D3(9k)Q#lIRFa$-QMQ0Ag+du3>-3gxC>4-M@{`CF7HQND*V4~{dR9vWJYG6!WR z%F9t6L|KjUF_f;?hK622=|g!Arz zqg;=&1!X77n^7J_`Dv7oq5LVzS5W>9_pjz@)eYH zVe#UZwsQ^BI-S}DSr+{O#%u<#Q}FlL&xeK%!57T#TxQR?#*w*Q?_x_PUwO%b8PlmD zwJ*b8-Y=k&5b`2?9sY7(8XAI2;up!K9N-210*nDGu{%FyT9=)%=63U*H1k`U4F;5C z^5^M(0puLS%t9}u&s3;RIdmY@?_+gVk~J!|>=%t>B$fziL@i=(iUo^hD= zU3f|9xQ6?}q(cL~&P|2uE*zr2(p96iekzSjir(qmE3p)SQ zlWK2zoHLOA8KCF?erV`2WBW*=eHrLJ(A$l4Q(L@!1L$7_o#G^J-|j^Fy`UcheWsDV zDM5b-^k>JQ9|t{hYV`iS4tnz_bQ*(iz(0+kZ$&-rhO~r@<$KH~X$SGW1ir)I3liV5 zB)*Ladux!B&VbJgzIcBP^cd(Dpg*IH$K9Ymi}pNatMMpL$bS^{BV*8C0{uSFQ^}`( zd;$Kr8}u7cPrC!maUJMyjnG4U!APF81yu(Ih4mrjq-OT zcU7W2JrMp~&}nZFr;GH!^XOjCY0Xa+uRQ;O{t?7^U|-Kz|CWOtwWL4mV1KlH z#`3Cz-RnpP>Osd0hQmJ$1Da%Ain27lg54lt&-60381)Sj{shXx^u=tAfc3@cRV;}5 zzpj6I;9nm2mk0jkfq!}6f9wJE{5AEwwfOVZ_~s%ZwkzW0fO>w9q7;V&Ucu`5XxJL_ zwVd#@Cadccs*+Ty=Tu>7=9hXt6_#3lspnGR)`(x~c~tUkc&461C66_jdj1rhpV6hB zJEhKx)bpmY1)06bH#@kkmGBt}i*s1U)N`erlCGX7g+pC_O}Jr_#dQ};^#Ns_Lf1EuyP>iJI>Nc!WFUyX%& z-qTb`e^Jsel(2ff6W-b3*E^E#m9ToA(?t?Cjvx7GDCv@H%s8%N@fpW^EIwl#jKyb+ zkFofSaWfX5F`mZaGsf9ie8%`2i_aLBWAPc|bu2z(9FN6kjPJ4djB!5}pK(5n#b=x+ zWAPd1&scoMc{LWFalVbkXPk#)@fqjmSbWBLI~JdDK99v`oabZl8R!34e8#*m7N0R+ zjKycnBV+NY=ftV!!l}Hdo(D(k4PErCQo0m;QxZ(iDy2*1^>0d8tqbaR4b-|YN3H`Z z&#LE_s=TW5vC6y7EnY5PaT<^$=TE~<= z$%ci(%Nb3QpU#cxQtOObKb61wy`0PxoHBy{*qLk8{ixC94;5?{(t|fem5`K&<|z{Oh&FKC&+S^EDL41OqOe9*(l2nS$;~E_sa6C zvi!a*pOxjWWO+uGAILI;ABN$*2U*UNWuYvW$#ShM8)exc%TLMjURi!smfx47wlugdcKvV2ySzmnw{S$-hPj7z0{ zSIW!WLiPs#FLS$LeXWFiN-4P zf>q6LUDBl>t4+e0vdogD)N7R+W2-d4O350RRoZKn8(*v3@LFX8vdRsvRc>spvR_u2 zC#*7`SY-mW%EYRv1SQn4Z!g`vjJm3x=PA+jK<+ENxwV_yTVw6sh4YH$Et%zGOf;C^VE)c8>84a3nsBn{7Wjyh;tMrRf@XtZt1^c4><=^s%&NB;)& zrhiOzuYNbWnm$DJTr2(1QaaNJ$g}pqm~@Q;Mb>Wvm2TodvGq69JdFcB>j243=RlQ} z-sw%x;J|uo9ZXBtwMG=1tY^s-o7N1V$$C8|Kzf!&2De$y5yi=Ym~}37+O2H|rPJym z3npkQ0CZWsm=x&~HTsa~t=4&XP0!IHkhaJAH+U$0igqi2{njvbf2MXT7!Fwf3nQOC zPrDnyLF;P-%;&%%>mLco)#}=e3g3Z#2_vLE<=9=P$rEhnVr>( z3Snt9IrgB!jsy070NKQAEhQ;+%=`nWFn^YZ^H(54n@Qfc+=|ijYP&y2^1cSw zXkFAprq6`=+AYMQ>+~~{+O4bc>ePE7Rog@O9A>Ens!IEIDY~RzLWJ+EpbV;0e$>8O zjk>OXl>|LX$MsIV3MOdZ3!$E)--cK1`!T$F^>i4a{l{+9b9E2YYmbrN^7J2|d)nhv zU#RaP{-abc()WOGAVIqRV-k8u2z`bGeTlpakCsAGj`mP4x+ARniorS_sk%NJ zBdt9wteZ!kK1@7Lu}gJo|4w5d8h^vk_?y%KUy0C3Q-)6Omt^CE*{C*9mHd&RhpD=P zS9emCI+3C8qbiw{p&y_sNzKsbLSBa6hk7Q3!?!`<(*<8F(ftKeJsAK)&7e4(blqH{m>|%ZqH_avg#ex9d0}dYtQS^upr`K+Aa7ukkv; z)d~DWd}uSiE>e>qV7rMN#YMSdVaC%+qVB1Bm z@!*;6`Uo07;lk$`*$meez|3^H!9UA2ADpvY-vVc@s}Po4>{f@gD}=U}xxNd@MXnBTUheuB zlCN<67B*k$x)85dxjqj$i(Ttr`PHtiuxg2GB6#|kYb(?oW3DS;-BZj}1mRCJ*J*GZ zXRchB^9*x+44Ka|*Aj4^V6G>?@*H!~F9`maxgJH}KhIn*p!rXjYaQDCl(~KldtnW#NIz(wy=WJq^&qrn7ycXSPJJ@rFZ%}SIr>`=o?Y}S)V=y^a9Z}|6oWLr z2;3eH(hGPUI#zwH)0X6XTFGjGMv|pf;>ZlaD5w4%^u>`)>^Zsx<~!`N%`DYILyNNWC8ppT+ z(l}md{NaC3BeDOp8h=L`NsVLNMl>7W1v^cZG%jZPjLL+y=#_vcP)AIaWcGw=G%!_C zoUn;M#&pv@snLh~v~R)_IS;~PKu{Xa`4eU>>a;hQR3GbP+HQ@O$>(OSTJQD1ZxMish>nSxg0*$?&giz)B|zMJpyy#w3r6cOfq{mH`{#I;3sF2*}2?o^IcuLXLiEuizW5I z?pd8M`x0*UHng4nXHs*iiAL%B1ovWyv^m^KLx6K{BZtoA)|u}*v^)29g6B#2$nM;` z2%gVj(_O{6_Y#;V!K#aYh7L}h2Nm+tt~9kEL@s$Bc-qun(vQk|s{9re8lX$Bmh4vu zKboTOW{sAIm5PLYQc|lRP+Mj?s)RkDggvE%ogrZlj4AB*l6r`Qtu|Tg(lWaF=9bN& z3RzZ#%B5_+=*0-j=3Ff)w0hCC6_RGtM_;w;Of-T~G@rXvGOa_$<^?4{(NYU;1V={4 z`A>e3HkV!6A!(cA9zcV$GQ6Tdevdbx5JPO$Sk3BC6@jKLoUW~*m-Xh3BfF<-8%!O= z(@oo%siO*oZtB>?=G*59E1&0LR+~HUMYs8DB=UDcHr&qUhb8WP#drXW-<3!U`h_^> zj3*^-3dcd>AuxJmH}VpUb7xB2LGr;TCGbrE_#z8Q({IL?9%ks?S#0i|lKK>=bAKR# zp8>$UDTF`s4x)+n4iB~DUrpA&Fa_&VK4r0EvgIHeYJV~nIFU1K=8{t3f(I5%0j$j` z$mMA77B9y?u#ngnEd=swP_?KS6-v#EDp9!&mBRI?Al@%)Kv`6bi89v-@{NFA1o_f0 z<_Y;P!d`Mx2f#Vy5_yrJu}#!u51QymLzf1UnqUCfoHmKX0PyP(YH}Bv(1(pKPo^%q zUs5jpWC~$y-jMXg>#*u)kOa%D=4H|q*z3tge+BssK}HwZr3)qAj?)e?;ymh{Wx^&z zoz+|;r6BrvXXVy=4u*kmy)R(7w}4&i)M#X^=2KBGZ_PL8YZTXXmOBGo(Eh5GaxV35 zbtc^obSf@nB{N1=+hV$dbE)^Tv+1$tnRJivWyK1$*I?(NZ8JU2S=HOz*`Fm=x^eiq zfpv(I*H=xib5`{Zc=nS3bH5L%+A}7)S+kl|m|U?CvNI0T9s3o(fQ1=fqw1A=@uHpO zCjgWxJhYy8XcZAPK9R4Y#g>*@$_8TVM(dKNm%Ot07fA5qj!@>f`d1J(?%Oo$Jp{8Q z^oR)OY+|NKf@P+)LfYzdym%iOhuq^J-(%%zV3Ibjc9d<}Myam5gi zh)QEOp@lpvb9%&CS@I#<09fQ%84j)thhY5R!Zd3I?3U+Y{QSa{>jy?2jio+I6X$I5 zbCQ?&>yinnpsL z*r(Gs?{)nopmZ8fGMkSyVQDlu_Nc;+!}#-aFL_Kw5n}y3f<7n1`4O0GbaR;Da+!g* z(am87pJKX=ZVofX(YD{ovZ-stVyB9oCLNSfb57y&NKg#qiQsood)WviG@`Z7O!_lC zKSg^4C!O1w^O2=2Uygyr5mQaT9U^Ww=B;kM0aab^!K;(bKX{ZM0>t}nVlI9jV*SFy zG_(16h?}2>xcPaAo1cfc`FV(&pNF{ld5D{zhq(E9h?}2>xcPaAo1cfc`FV(&pNF{l zd5D{zhq(E9h?}2>xDSy+H$M+?^YajQ0KFLR=I0@9ejeiH=OJ!>9^&TbA#Q#i;^yZe zZhju(=I0@9ejeiH=OJ!>9^&TbA#Q#i;^yZeZhju(=I0@9ejeiH=OJ!>9^&TbA#Q#i z;^yZeZhju(=I0@9ejeiH=OJ!>9^$?e))u(=d5D{zhq(E9h?}2>xcPaAo1cfc`FV(& zpNF{ld5D{zhq(E9h+CY8xW##hTbzfu#d(NZoQJr@d5Bw_hq%Rgh+CY8xW##hTbzfu z#d(NZoQJr@d5Bw_hq%Rgh+CY8xW##hy9}{J=ON=BMq1u)vR;tB8jDaSokLou@;cs& zriJms^jpzkrg`qeTSC@p9MUzCzmj{(o^W0CI7jej=d2WD6>vYbUqj`RT*tLFw z)4ZDJ6)X$Z8R-WQh%+?LrwN+Lp*+nqK<#F6&Z{)fJkl_mODWboeWW3m(|np|C&|2+ zLzSARc>xL5P6Bz=V( zx?S^phBREp`+m3PIZ4`!IPH+;xrm_4Iqfjo5p)HI9@RX@sP9*D4SkyDd6Ib*Z+Bet zbWm>>bIzY?p0ALGt2ylz&9j$mS;E_$(mc-+RLp6wYn~WsDB%O`i26Wd(y;e3%H(;T+O6VHvB~ot z;;iCOnaM+Mds$Oo&b4{JD7Y4ZG>G*ok_%H&x}QffFNodXr}{$z03( zx5?yrie#?iv?i11QG(WUsM+LMN6-ciwV6DxlFaKk6f=3w5N#ueI!&H_(q6}*n@yf^ zc$*b(ebLI*W%Afa-whnX9+NLq0ZdY!z=v>xjI3^bCY^Hncsj|nKA*l1b@Oy|&-U59 z;MDa`RHTOk8WkP5CLcq^-MC#)^DeV^Kfs9t8fh}v#D0v?|&L_Fc|qh4kE9ogAQ^4Hs*M1Qk((n7k) z)-tyV9$nwTU+=`L`Argf?EsjpaceP8%JGJM2G3-D9I8afgFqHOEFr;tnSbsMkhE;tm&y z%;j^<;ik5EP)wf^;78()aa6U^`82fu2!+)C)c+>!Br;k18sPYmxMLhut^7#bX~~DV zyuVKC&$)Iw5_j6DuG{EH+{yEU(?&<)&TL}OvC)yZlW&8)Jcl?PE6~SW?jNU%{4)pr zT}~QFjdR>d(#Vg*ot7{E_cRjwKdbQ>(nxBY<4V!Yd>6*lZv7FePO2i-QJsk7%QT%V zPQG{5zVIa^f}9V*tLao-i2%v@E&^H89|m|IflG*LCF(B-T!0*>S?5C9G(^Ot*YZ%q z^%CgC_?s*ak=dlPlJHj`*9!t2wM-J(X6@J_}d=We{N zG3~HW0S1CJb8MHv^I;{&+ z8_*T!g%ow~0%<3Toob-}8O4PpYw9k{Z|8+HF~-sC<4jZo(}z*iS$jt zGvVSLn>Y`mVSBpZAbO6ZbE%U6=tL(KlNXAX9Jl~LoHE5GDHtJi47?X+Y8VKkbn29Qnl=(QU!D)QF=Wh<-b61?DIkb8HmiqdUEcg(n zYA-mYuwlT+X3-rG+!SsJ&TkI2-?&YQm>*~j;8C&-fdz3)+m2XMxOKt2!WL->J(_lY zJsu~mSpI<^GCeM2el!#d&TYdZy8~N-(fN2hb$!$P_E@MnIv>ySo*o-%q>7XFFV@ameADL91g^c>YDKwaU)zG?BJqdRojkWBodBL=KzIT z5>f)2;f{c^7)!57y)kcoAWa+hp*iasb4+)ev(}qqx87>bdR>20uiVg-W-{M*^EH^; zXUy|>J;v)-@%jNnop}1q>-8hD)t$W6S>Ec-o2k`VGqt+&W@@GC)ardhtG&F{dERO- zZ*`ux+RIz1I<@+kw;HF9-?K&k=9Yctj{EUWhL&-EhPh7nn&;0m->#XaYv#Lmd2cem zVTz%$-ZX2{hAS86KY%~|OZqtTZ%q1o=CAF#|7G*9O!LeS?RpOfCz?iYMB|PhuOlbA zVX{?4!dvh-X3UCuJfOQ}{+hYVmad$KIYP5xZc8AFr=RmlfZ+@_&&NaW=SL&;!)COc zi~rrMFftK{6k{+>O}s=V_+OpC|EK5g|Es)|$Q$Zs36MKPx)9SI=^~yw5EE)zBQvPf z0gf79Ni#j}8-p)qUR$gw5)3pLxM`AeTqWgRa3L`yr3$2m`u5Gufv7*w76J!{qj>6f zlv0aG9En6C5=(UqdRm0Icph03Xl)25kYgnqmGsaFW^o?s{Cx@dyCDj1BE)Yk{2(UN8wiyh^yfz8dq1}+)~`04j1;zsxak%sMf(0+9c z%NjQ;K`Uu!h(OG$#-;L6`>Y`l3q(UZg9#qli9o2iJz_ww3}4HgS~1nZG3vK{Q5LKus?U z0sYJX3;P3+Epq4^=!Zo7G?a<)sAvtvLWq`~0g92N0Tn%}3AF^n?J-uh17!cI`ug?= zerN#^8t4cT62az&*Dz=mG^yzK0;tEBJ8`AL{uP1FvLF&o zd1rkv*nmb2Nx>z8En3?e=zvct_?f>gjQB#A5RN>TNgIW|Twl125*|4wu1|&_eBT(_ z(jMV1<}b>B~BiU}HTALM7VXoWk;^Kr2#OSuk233ALg7DIAQEqcP*t zngR;z0L>gq9r$?~3PwQmJ2mZX0*>1kAJ-a;6Q=+0aZTi*+E%%*!&t=|8>b-!ErmY? zfWHBu#}G(xg)!bj(I|JDaVT0b-GX?DB5dh5Tl~u+;g+@GP(xKLlF%eaQ5p$WG57sT z;q(>81W!fnXq3GFrE@QOg|4)O*? zAjTd$b(+cXsV&FExL{ztsM_H#3yQE10~Bs-j0Q&zu}ER)l^+h;8H8z+{|xg>c7J6! z(o!9a#o$EN7K=258XJihV=Hn^V$eZNm|qf&1|tTowXH3Iw$k>-#$ZIaQI1=DTvaTD zW2HQ&@*4uVGFI&z5Dnd&QAYY~-kn(W`&Ky&*@ ztXy{zO978)ikso?PRuWwR>aPyIOk5*gcTcmT;)rdR8}R84tlYM7GIHU+9IKrc;JmN zU8cnZenqG=*dRUJB@CK|+u( z9F3_=&G!Opf?GngLpMgKbf96u#w=_LG~|n-Koko^u}~C?42gucKL}W!xf>HplD`AL z4AdO-C&z91(xtVn^mn##)^A{s}$?4ahVW3 z<^h4(R|%H{$uEY5L`_h#g2~eDfvRMv=(l` zh8SU;;Fkj{0%;jGo7`*R&B*PI^%Umd#!Q6vZT?22-w`dVLb3X$q=^+z`fCG`5ShWV zK5dE;%~yuiyo)dA2#|P!iccuH!;0^Kkvrfy;d*T7VnNmz2^uDKZR@ty@OHxr$;fQl zc=FU2j^KBWD6IUA2A&lu^A+3`LY8dDbVt53CUogFx%sU|uEG*1f?F(Ylk87W$!34RE424sI~+ltide4xuARd zgkB2%;ajfw5Mn-JF$mR%u(K`WCqQiZ%3AMI@kMIy+?H5-YjCkVqyiYgDZyf#70xYO z=$*U8J9pIr?_8{ki|a4H+&i~%dnC}-fwHP%DPDPW&TWf?V;ED~yF`cGKgpG5Sr9?0 zb`Nl^*z(gNCVqg;Px%R9g$+1vl>DMtA%2_9&<*T*Lk&`7DK@aQPQn1hpx6i)cL6*j zR3M4L*|8Ajfatl}qX%2sVmp@7o*DZxv4qDJA*>^@_BOJY;+B%SA*cH(Mi2z8W!R%* zqldJw#u!0GcaYxr5Ya+~xy-|iLW=S`-;;KPg4-E3vV7mm12^1Ok1c^QxK<#AH1mC= zjB{*90Mh+QV%TNMRUF6@0ouLr8z8I-@Qaw{CF&*x5#1ia#=W_{#V`Sfr6Cn`afd8L zhK6730;RY%gP27^uwzD}{6BdcQ3i%~O1B08s#x-m(5 z8h>ne@avDFbxWXA25CWAWdNt1Shj#$j%>yaAor2y5@SLEBy>i>*@_z=I!VCI8-jC7 z6y4zZFv}=&VV02weqa+t5V9u7T8VCU1WRJ!mQa1dFR^ee(7c@A>_Q$B=QZLkT{u2D zION$7j#+k4h{G&#vn5)pAxU&Fzf4X&aXaOw!v~BgGC_UQ@}*@2fmv>z1hY6LqFjM9 zjW+I(guH?>Ml-fO7R2liqU~1ETPXqL1aE%XiclMNx;%nv*OnyQxh)uM6NZOdiJa3@EnYR#4TBC_JQ$BF(zq#V9d zIxeF2aZjkYP^SZ!k-XbX{OleLX~K{3eLa^-6v0!73ii;BDW zl0?FYdjfYl6kp=_iG~;Um%Lrro43vejk(HB(t`H zHX%^m7PN#~F>=!R5Fi4r6bFd%kjQW>$*|pwx8q@7+8$jOYKS!%T)wn@bC3p`Tp&Up zQiWeB%TbC_$51q3gg)wCLg(;zq%gbx2Z!WzSk8}ga0}i7*U;_@OL7Qnc!NyBv?@U_ z&j`a@iy2;>at4hTQa92=)|-h9(widB3q^Clr&QHjAFeSKeq|ttgSv&7H+}fiJ!Zmb8a;s z#GS*4Sq^ptDR{YwxbKd?3=hDQu)l6hnjUx=Uvv4-VfX=0d- z3()dNxV;Tb^?_FGq!WuW(vLj1P0WZkOn$m0z`UlzL2-_Pa21-O{G>fB);WI+6D``L zg4sBc=8pBs#>FXaUFU75~8dWtmtobJzu1?i(^*_-tklZkX z@h{|#Xi6VWq6;57f~0e~)`R5eT5WoGyqsh}oa72=x`rLn5t%c?yts;XF4!wFPEgs8nDNxx07 zsH(C}zUoM^*n;R_QxFbV2=x zvZ|humBOOiBny4%TC}QC)i1|UYgF~W;;6Ms-8*qqm8!lQN39)c!CIjw@k-y>qU(F{ zR#mE17Tyr03msNf)fF?l>#^N}ns`;B3}z}(s-4D07@!mze3=j_YO1q|o{bnJ)nvA; zAUCLLM;ukBs=FjAb?Q;F3gQiGRMpsUWS$w>aJ6c*ZpKGYRK_tjGeg@EY2a{t8dJ|j9ga_D>iMF>@fl1#mvlJZ!qoFk zhvRkD?=@mX-HfkesOP^Lsb*$lr_}s15X>x-bwH!)`&t`K zz;d>v;-ARWSKf#7=de`ITQ##u>_|A396TJdEfxL(mg>2hW;}8JP&5_)RMwXgubz5t zw37ThZ8$G|OLG($zb5W-1SJ5bV+9q;8$Am^HhV@ANa}tkFUh?bP zz>}Zn$}e%?yJ`ITz2rZcB(ujH=;p6oo8WKT@u zUrEB>A>}klITs0W>{}AwE%BK7{CWj=d`)6RKBR|Nkly|z`4h0Nko}*R_A5DyB>vzP zLT%3J_f}-U2k#zM4q9~$MXy0PkO&6_4*__4|ol~F3}(b0OVIW z$0zbReFuiF>wqUY>i0Ot3p8Y;j-NwZj++&4l8myThajfP14K?0hetX81?-^AlPa!$ zCGByR3c<>szm@#SdH9bUKQhn14?MmWG-92~z(m$k z>G0cIO9VVq5?4!n<6?op_YL{g4m^Fk|I0Goo|O1UQ4(H#Tu|*o9|V6Yy}um=|2ptq zDRWqXPdt+RQaMju($Oy9Q^}tNJoT%!SV);Jg{>WhpB~MbN>1A-_Z@?Gq+(yks&IGe^PC2cGw1w=? zlk=!n^3%f|2!D+nFLk`NOX54E-mQ}Ve&F4*ZY;h7e5&z!eiS@C*@*PMC;fAy6!!io z{PdtF;!hsmT;Nmby;Ab;l=4*^(jz%i@!v8E{xiUPjUAQsFG=~yv3`j^ zCG`fS-?XgM^7T>h7XVNFP0mY8N8zuL{Drb#MN;o>&Oeo%lluXQX2-C8rRwiqDQAkD z7s@|Bk@)2K_^OnjoM+BR{v&dps=P{1iKl+mC5_80iT|_ItN1G={!`M=3uOmxlKABD z-4A@KejSqhPfB|(mU51b!vBj=@NbNQr$^zW(rZUYyvpf@aysy-_;Z0L|GZi(nB_Kw ztpz?+{%Mo^Pe^`%{CYs*lk->~@Tv6v1bDA(Yb@T7a+24tiP+$goz7yxt=6yE5}!Q2 z3xQ9immXb|s$XlRoEv03ERsgGk0R#|&Tq6_)W6QHga5Hx-!z(Nr1pM+$e|vr}2VIQaTDqA)U0k+ngj5BF{fc zF(SE3X%GAhxzvd%0wYZT1Fl>chFx4?7%5ZONB}oBT)D721Mcj`fPnxmjT9;Jz4zvk zqv4MZUO@L|X6MbkdGqGYXyDgh32$%9N2;C=a$-T>B%cL1HyyG}E2W&H~dvM?PW>AYIE zxE6zA*Ho?5F41N^Kdc&)0bT}3nK=!MB+d~7q2f-oO*w&1*BYkhSC}rTzyn|bc@2sX;K2 zaobfx!>|+~kCD~a&$E1bVpj_R*$JR8+K0H0QPELM6>~ezGlPfP)>Z*|F`Gq#8ZWgv zbIZ3n18WOSmYJlwy|q_iJ!O8AXWTNAJI3@8= zlHPwcfH4KeoL^m;Apre@K45eC)La6BjXQcWcaw| z-9JH5<7iL&uyVhAa8QpLrm=hbFrq0xt`EB7sCIBtAJh%-qF7l~LG+6OV6@+))K_D&4qU&%=)EG>r2MHAJxNS35at1@mJVIp-sVW{NI8w3uR$J;3^X(^ZiqhB|uu$Tz6 z5_*qn(>c1{4eKzczOnxnW8ng}ZgxY0?9NsHh_$ZeArpp27y^$KZYanYmD?Pl3@fmx=to^M?; z_BEc?o0!TdyNcj3d7aL^6+D_aES|WK96F-jMhu4}GdX6_kLP8OHY`(?EW}D(5`)XZ z{t9;~?6%)|DPpU;d!+~>7KMZ4f{CHPSir1{z$7DH(I%LBwwaW%eQwMP%})ifP2?`t ztEY%`lhMf!|`K%+xxt7=okT=!(lmC`JJ6Rhw<$_Qwl27N+rp9 zWen)Sg9nsdn76QMj>Ohz6Jdv!(&(p4AdbvGS2$K$s?#6dLNkZ}fzd-Aj%Fi!I6c0% zZmm=S4C44M*3_bKm`)N!<^o_Kgq6&PR|*j8K_jYWgE8AgCB_g~HN2e?LVu0O`!qjJ zc$P#wtg#9fhK$Q$(wMF_{md0c7AiA$Z9j8X3769-EDRjZvqw?7gv}O~NdR{65IXJVm#5y{0bJ#c7 zMZtwZtSmeS5%0j_LQP)BZztYiqsQd`@fkaN@w>r)lIAw#0j3$=HJv{r)I3jMgdG z)E=hzG*z~{pttSHR%JaT*{z(?<(RYdkh9JpXFDwKrMz{zdns?O^SxDE877X-g4l@e z_a7oWg(9?}X^eDl&y<5AbcRhwPBXH|`E2M|Dy#{|6`Z374`DxvSf1()dmK)(f1&p5 zw#I&+9Ee!5rw|sZ5R9ii#PEUUBcT_X>LX|;z>zd)O|owCQkE1rchLmqGf1X=a0TUz`^ z^K(j`2NSM7aJMLr;&qh1V9S;8b)9BF1N{7izwN91itADO=@U{J*Q5O4+Tq$m-&gUe zch`y*+yazqa>3k6&>{807q{qF1i`KHyuMQ%d90wA;i} zx#Z5=LZtn=1Ss~)hy|x}e*XMBq57|1mw?B98P)yv9pQKycop~Y>t-wXe|%rKo_o^e zUhHdP`F;I8`GN4g{>*ZImE(;S{hxgze6M=zNBOi>!OdxIPXG0pq=z1Zmu1~~CeDn% y|6KT=wf_4>WdDR8wR^Qo+F#W6ghT$_`C8}~o&)#$|J4fqUwkk8?|KYgw(x(X2^}*4 diff --git a/lib/model/nms/src/nms_cuda_kernel.cu.o b/lib/model/nms/src/nms_cuda_kernel.cu.o index 56e59f5bfd3409b6da821eda9bf799d3ca0442f5..c7c708c543c687595135b966a9d0e0c31db601b2 100644 GIT binary patch delta 35 lcmZpe!_+W`X+y0Wvq7T4<_5P-Od!T&Q_o7Uz(!Ah7XaLe3-bT~ delta 35 lcmZpe!_+W`X+y0Wv!Rj2<_5P-Od!T&Q_o7Uz(!Ah7Xa0u3xNOt diff --git a/lib/tracking/detection.py b/lib/tracking/detection.py index 72ad706..2721fc0 100644 --- a/lib/tracking/detection.py +++ b/lib/tracking/detection.py @@ -33,7 +33,7 @@ class Detection(object): The motion vector for this bbox """ - def __init__(self, tlbr, confidence, feature=None, im=None, mv=None): + def __init__(self, tlbr, confidence, feature=None, im=None, mv=None, residual=None): self.tlbr = tlbr self.confidence = float(confidence) self.feature = feature # [c, h_f, w_f] @@ -42,6 +42,110 @@ def __init__(self, tlbr, confidence, feature=None, im=None, mv=None): self.mv = mv # [2, h, w], tensor self.im = im # [3, h, w], tensor, the patch of target + self.residual = residual # [3, h, w], tensor, the patch of target + + def show(self, type='im', track_id=None, show_size=(120, 40)): + """ + This function show the history of this track. + :param type: the type of history to show. If type is 'mask', var track_id is + used. Then the mask obtained between this detection and track is shown. + :return: + """ + + if type in ['im', 'mv', 'residual']: + feature = self.feature # [c, h, w] + if isinstance(feature, Variable): + feature = feature.data + + feature = torch.norm(feature, dim=0, p=2) # [h, w] + feature_max, _ = torch.max(feature, dim=1, keepdim=True) # [h, 1] + feature_max, _ = torch.max(feature_max, dim=0, keepdim=True) # [1, 1] + feature = feature / feature_max * 255 + + if type == 'im': + if self.im is None: + raise RuntimeError('Track do not have image patches to show!') + frame_type = 0 + show_data = np.asarray(self.im.permute(1, 2, 0), dtype=np.uint8) # [h, w, c] + elif type == 'mv': + if self.mv is None: + raise RuntimeError('Track do not have motion vector patches to show!') + frame_type = 1 + show_data = np.asarray(self.mv.permute(1, 2, 0), dtype=np.uint8) # [h, w, c] + elif type == 'residual': + if self.residual is None: + raise RuntimeError('Track do not have residual patches show!') + frame_type = 2 + show_data = np.asarray(self.mv.permute(1, 2, 0), dtype=np.uint8) # [h, w, c] + + show_w = show_data.shape[1] + show_h = show_data.shape[0] + plt.figure() + show_data = compressed_frame_to_show(frame=show_data, frame_type=frame_type) # RGB images + plt.subplot(2, 1, 1) + plt.imshow(show_data) + plt.axis('off') + + plt.subplot(2, 1, 2) + feature = np.asarray(feature, dtype=np.uint8) + feature = cv2.resize(feature, (show_w, show_h)) + plt.imshow(feature) + plt.axis('off') + plt.show() + elif type in ['mask', 'masks']: + + show_h = show_size[0] + show_w = show_size[1] + + one_mask = self.mask[str(track_id)] + mask_t = one_mask['track'] # [num_f, c, h, w] + mask_d = one_mask['detection'] # [num_f, c, h, w] + show_feature_map(mask_t, save=False, show=True, show_size=(show_w, show_h)) + show_feature_map(mask_d, save=False, show=True, show_size=(show_w, show_h)) + + # mask_t = torch.norm(mask_t, dim=1, p=2, keepdim=True) # [num_f, 1, h, w] + # mask_t_max, _ = torch.max(mask_t, dim=3, keepdim=True) # [num_f, 1, h, 1] + # mask_t_max, _ = torch.max(mask_t_max, dim=2, keepdim=True) # [num_f, 1, 1, 1] + # mask_t = mask_t / mask_t_max + # mask_t = mask_t * 255 # [num_f, 1, h, w] + # + # + # mask_d = torch.norm(mask_d, dim=1, p=2, keepdim=True) # [num_f, 1, h, w] + # mask_d_max, _ = torch.max(mask_d, dim=3, keepdim=True) # [num_f, 1, h, 1] + # mask_d_max, _ = torch.max(mask_d_max, dim=2, keepdim=True) # [num_f, 1, 1, 1] + # mask_d = mask_d / mask_d_max + # mask_d = mask_d * 255 + # + # + # if isinstance(mask_t, Variable): + # mask_t = mask_t.data + # if isinstance(mask_d, Variable): + # mask_d = mask_d.data + # + # num_mask = mask_t.size(0) + # if num_mask == 0: + # print('Nothing to show, the number of masks is 0') + # else: + # plt.figure() + # n_rows = 2 + # n_cols = num_mask + # for i in range(num_mask): + # one_mask_t = mask_t[i] + # one_mask_t = one_mask_t.squeeze() + # one_mask_t = np.asarray(one_mask_t, dtype=np.uint8) + # one_mask_t = cv2.resize(one_mask_t, (show_w, show_h)) + # plt.subplot(n_rows, n_cols, i+1) + # plt.imshow(one_mask_t) + # plt.axis('off') + # + # one_mask_d = mask_d[i] + # one_mask_d = one_mask_d.squeeze() + # one_mask_d = np.asarray(one_mask_d, dtype=np.uint8) + # one_mask_d = cv2.resize(one_mask_d, (show_w, show_h)) + # plt.subplot(n_rows, n_cols, n_cols + i + 1) + # plt.imshow(one_mask_d) + # plt.axis('off') + # plt.show() def to_tlwh(self): return tlbr2tlwh(self.tlbr) From c4365e3818e98333a47617350db941fc987e881f Mon Sep 17 00:00:00 2001 From: LukasBommes Date: Wed, 8 Jan 2020 16:33:51 +0800 Subject: [PATCH 3/6] updated readme --- README.md | 34 +++++++++++++++++++++++++--------- docker-compose.yml | 3 ++- 2 files changed, 27 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index 86b9785..1118eb6 100644 --- a/README.md +++ b/README.md @@ -17,26 +17,42 @@ There maybe a slight gap between the performance obtained by this script and the ``` ## 3. Requirements -``` -PyTorch = 0.3 -python >= 3.5 -``` -## 4. Usage -1) before running `OTCD`, [`CoViAR`](https://github.com/chaoyuaw/pytorch-coviar) needs to be installed. Please click the URL for the usage of `CoViAR`. +[Docker](https://docs.docker.com/install/linux/docker-ce/ubuntu/) +[Nvidia-Docker](https://github.com/NVIDIA/nvidia-docker/wiki/Installation-(version-2.0)) +[Docker-Compose](https://pypi.org/project/docker-compose/) + +## 4. Quickstart 1) down load this repo. ``` git clone https://github.com/liuqk3/OTCD.git cd OTCD ``` -2) download the pretrained model from [BaiduYunPan](https://pan.baidu.com/s/1-Enzek8SQpnr1BY1uzde4w). Then put all models to ```./save```. If you have any problems with the download process, please email me. -3) run the tracker +2) Build docker image +``` +sudo docker-compose build +``` + +3) Download the pretrained model from [BaiduYunPan](https://pan.baidu.com/s/1-Enzek8SQpnr1BY1uzde4w). Then put all models to ```./save```. If you have any problems with the download process, please email me. + +4) Download [MOT Challenge dataset](https://motchallenge.net/) and place into a sub directory of OTCD. If placed outside of the OTCD directory, edit the volume mapping in `docker-compose.yml`. + +5) When finished start docker container +``` +sudo docker-compose up -d +``` + +6) Enter the container +``` +sudo docker exec -it otcd bash +``` +7) Start tracker ``` python tracking_on_mot.py --mot_dir path/to/MOT-dataset ``` ## 5. Code for training -The training scripts are also published in ```useful_scripts```. You can train all the models by the given scripts. \ No newline at end of file +The training scripts are also published in ```useful_scripts```. You can train all the models by the given scripts. diff --git a/docker-compose.yml b/docker-compose.yml index 1907849..24fc925 100755 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -12,6 +12,7 @@ services: volumes: - /tmp/.X11-unix:/tmp/.X11-unix:rw # for GUI access - .:/workspace - - /home/lukas/mv-tracker/data:/workspace/data + # example for volume mapping if MOt data is outside the OTCD directory + # - /home/lukas/mv-tracker/data:/workspace/data entrypoint: ./docker-entrypoint.sh command: tail -f /dev/null From 2794c479f3ee39ff0d3b07cbeaff454b13cd7350 Mon Sep 17 00:00:00 2001 From: LukasBommes Date: Wed, 8 Jan 2020 16:35:38 +0800 Subject: [PATCH 4/6] updated readme --- README.md | 8 ++++---- docker-compose.yml | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 1118eb6..91fbf79 100644 --- a/README.md +++ b/README.md @@ -18,13 +18,13 @@ There maybe a slight gap between the performance obtained by this script and the ## 3. Requirements -[Docker](https://docs.docker.com/install/linux/docker-ce/ubuntu/) -[Nvidia-Docker](https://github.com/NVIDIA/nvidia-docker/wiki/Installation-(version-2.0)) -[Docker-Compose](https://pypi.org/project/docker-compose/) +- [Docker](https://docs.docker.com/install/linux/docker-ce/ubuntu/) +- [Nvidia-Docker](https://github.com/NVIDIA/nvidia-docker/wiki/Installation-(version-2.0)) +- [Docker-Compose](https://pypi.org/project/docker-compose/) ## 4. Quickstart -1) down load this repo. +1) Download this repo ``` git clone https://github.com/liuqk3/OTCD.git cd OTCD diff --git a/docker-compose.yml b/docker-compose.yml index 24fc925..c37612f 100755 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -13,6 +13,6 @@ services: - /tmp/.X11-unix:/tmp/.X11-unix:rw # for GUI access - .:/workspace # example for volume mapping if MOt data is outside the OTCD directory - # - /home/lukas/mv-tracker/data:/workspace/data + - /home/lukas/mv-tracker/data:/workspace/data entrypoint: ./docker-entrypoint.sh command: tail -f /dev/null From eaf5c6dad75808c3c5a8174706c95cd5e9c181da Mon Sep 17 00:00:00 2001 From: LukasBommes Date: Wed, 8 Jan 2020 16:37:40 +0800 Subject: [PATCH 5/6] small change --- tracking_on_mot.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tracking_on_mot.py b/tracking_on_mot.py index 3e12ff9..4517ab8 100644 --- a/tracking_on_mot.py +++ b/tracking_on_mot.py @@ -207,7 +207,7 @@ def parse_args(): print('tracking on ' + seq + ' using ' + det_name + ' detector ...') - video_file = os.path.join(args.mot_dir, one_dataset, s, seq, seq + '-mpeg4-1.0.mp4') + video_file = os.path.join(args.mot_dir, one_dataset, s, seq, seq + '.mp4') if not os.path.exists(video_file): raise RuntimeError(video_file + ' does not exists') From 50c117811172eabae4a93fc96e64f8223b2709a2 Mon Sep 17 00:00:00 2001 From: LukasBommes Date: Thu, 9 Jan 2020 09:24:07 +0800 Subject: [PATCH 6/6] added compute metrics script --- compute_metrics.py | 106 +++++++++++++++++++++++++++++++++++++++++++++ requirements.txt | 2 + tracking_on_mot.py | 7 +-- 3 files changed, 112 insertions(+), 3 deletions(-) create mode 100755 compute_metrics.py diff --git a/compute_metrics.py b/compute_metrics.py new file mode 100755 index 0000000..661a306 --- /dev/null +++ b/compute_metrics.py @@ -0,0 +1,106 @@ +"""py-motmetrics - metrics for multiple object tracker (MOT) benchmarking. + +Christoph Heindl, 2017 +https://github.com/cheind/py-motmetrics +""" + +import argparse +import glob +import os +import logging +import pickle +import motmetrics as mm +import pandas as pd +from collections import OrderedDict +from pathlib import Path + +def parse_args(): + parser = argparse.ArgumentParser(description=""" +Compute metrics for trackers using MOTChallenge ground-truth data. + +Files +----- +All file content, ground truth and test files, have to comply with the +format described in + +Milan, Anton, et al. +"Mot16: A benchmark for multi-object tracking." +arXiv preprint arXiv:1603.00831 (2016). +https://motchallenge.net/ + +Structure +--------- + +Layout for ground truth data + //gt/gt.txt + //gt/gt.txt + ... + +Layout for test data + /.txt + /.txt + ... + +Sequences of ground truth and test will be matched according to the `` +string.""", formatter_class=argparse.RawTextHelpFormatter) + + parser.add_argument('groundtruths', type=str, help='Directory containing ground truth files.') + parser.add_argument('tests', type=str, help='Directory containing tracker result files') + parser.add_argument('--loglevel', type=str, help='Log level', default='info') + parser.add_argument('--fmt', type=str, help='Data format', default='mot15-2D') + parser.add_argument('--solver', type=str, help='LAP solver to use') + return parser.parse_args() + +def compare_dataframes(gts, ts): + accs = [] + names = [] + for k, tsacc in ts.items(): + if k in gts: + logging.info('Comparing {}...'.format(k)) + accs.append(mm.utils.compare_to_groundtruth(gts[k], tsacc, 'iou', distth=0.5)) + names.append(k) + else: + logging.warning('No ground truth for {}, skipping.'.format(k)) + + return accs, names + +if __name__ == '__main__': + + args = parse_args() + + loglevel = getattr(logging, args.loglevel.upper(), None) + if not isinstance(loglevel, int): + raise ValueError('Invalid log level: {} '.format(args.loglevel)) + logging.basicConfig(level=loglevel, format='%(asctime)s %(levelname)s - %(message)s', datefmt='%I:%M:%S') + + if args.solver: + mm.lap.default_solver = args.solver + + gtfiles = glob.glob(os.path.join(args.groundtruths, '*/gt/gt.txt')) + tsfiles = [f for f in glob.glob(os.path.join(args.tests, '*.txt')) if not os.path.basename(f).startswith('eval')] + + logging.info('Found {} groundtruths and {} test files.'.format(len(gtfiles), len(tsfiles))) + logging.info('Available LAP solvers {}'.format(mm.lap.available_solvers)) + logging.info('Default LAP solver \'{}\''.format(mm.lap.default_solver)) + logging.info('Loading files.') + + gt = OrderedDict([(Path(f).parts[-3], mm.io.loadtxt(f, fmt=args.fmt, min_confidence=1)) for f in gtfiles]) + ts = OrderedDict([(os.path.splitext(Path(f).parts[-1])[0], mm.io.loadtxt(f, fmt=args.fmt)) for f in tsfiles]) + + mh = mm.metrics.create() + accs, names = compare_dataframes(gt, ts) + + logging.info('Running metrics') + + summary = mh.compute_many(accs, names=names, metrics=mm.metrics.motchallenge_metrics, generate_overall=True) + str_summary = mm.io.render_summary(summary, formatters=mh.formatters, namemap=mm.io.motchallenge_metric_names) + print(str_summary) + + # print to text file + with open(os.path.join(args.tests, "mot_metrics.log"), mode="w") as text_file: + print(str_summary, file=text_file) + + # save dataframe to pickle file + pickle.dump(summary, open(os.path.join(args.tests, "mot_metrics.pkl"), "wb")) + + logging.info('Completed') diff --git a/requirements.txt b/requirements.txt index 8ed1af5..ba92138 100755 --- a/requirements.txt +++ b/requirements.txt @@ -8,3 +8,5 @@ Pillow==6.2.2 sklearn torch==0.3.1 torchvision==0.2.1 +lapsolver +motmetrics diff --git a/tracking_on_mot.py b/tracking_on_mot.py index 4517ab8..b3768fb 100644 --- a/tracking_on_mot.py +++ b/tracking_on_mot.py @@ -65,7 +65,7 @@ def parse_args(): args.dataset_year = ['MOT17'] # ['MOT16', 'MOT17'] args.detectors = ['FRCNN']#, 'SDP', 'FRCNN'] # ['PRIVATE', 'DPM', 'SDP', 'FRCNN', 'POI'] - args.stage = ['test'] # ['test', 'val'] + args.stage = ['val'] # ['test', 'val'] print(args.stage) @@ -85,6 +85,7 @@ def parse_args(): args.tracking_box_transform_sigma = 1.5 args.tracking_model = './save/tracking_net_single_resnet18_mv_residual_2_10_6034.pth' + args.tracking_net_data_type = 'mv_residual' # ----------------set the configures for the model we trained on motchallenge ------------------------------ if args.large_scale: @@ -207,7 +208,7 @@ def parse_args(): print('tracking on ' + seq + ' using ' + det_name + ' detector ...') - video_file = os.path.join(args.mot_dir, one_dataset, s, seq, seq + '.mp4') + video_file = os.path.join(args.mot_dir, one_dataset, s, seq, seq + '-mpeg4-1.0.mp4') if not os.path.exists(video_file): raise RuntimeError(video_file + ' does not exists') @@ -230,7 +231,7 @@ def parse_args(): if not os.path.exists(detection_output_path): os.makedirs(detection_output_path) - time_file = os.path.join(tracking_output_path, 'time_analysis' + det_name + '.txt') + time_file = os.path.join(tracking_output_path, 'time_analysis' + det_name + '.log') tracking_output_file = os.path.join(tracking_output_path, seq + '.txt') detection_output_file = os.path.join(detection_output_path, seq + '.txt')