diff --git a/.claude/settings.local.json b/.claude/settings.local.json index 527ad7d..a809e01 100644 --- a/.claude/settings.local.json +++ b/.claude/settings.local.json @@ -220,7 +220,8 @@ "Bash(ninja ANSODEngine)", "PowerShell($env:Path = \"C:\\\\Program Files\\\\Microsoft Visual Studio\\\\2022\\\\Community\\\\VC\\\\Tools\\\\Llvm\\\\x64\\\\bin;\" + $env:Path; & \"C:\\\\Program Files\\\\Microsoft Visual Studio\\\\2022\\\\Community\\\\VC\\\\Auxiliary\\\\Build\\\\vcvarsall.bat\" x64 2>&1 | Out-Null; Get-Command ninja -ErrorAction SilentlyContinue | Select-Object Source)", "PowerShell($ninjaPaths = @\\(\"C:\\\\Program Files\\\\Microsoft Visual Studio\\\\2022\\\\Community\\\\Common7\\\\IDE\\\\CommonExtensions\\\\Microsoft\\\\CMake\\\\Ninja\\\\ninja.exe\", \"C:\\\\ProgramData\\\\chocolatey\\\\bin\\\\ninja.exe\", \"C:\\\\tools\\\\ninja\\\\ninja.exe\"\\); foreach \\($p in $ninjaPaths\\) { if \\(Test-Path $p\\) { Write-Output $p } })", - "PowerShell(cmd /c '\"C:\\\\Program Files\\\\Microsoft Visual Studio\\\\2022\\\\Community\\\\VC\\\\Auxiliary\\\\Build\\\\vcvarsall.bat\" x64 >nul 2>&1 && cd /d C:\\\\Projects\\\\CLionProjects\\\\ANSCORE\\\\cmake-build-release && \"C:\\\\Program Files\\\\Microsoft Visual Studio\\\\2022\\\\Community\\\\Common7\\\\IDE\\\\CommonExtensions\\\\Microsoft\\\\CMake\\\\Ninja\\\\ninja.exe\" ANSODEngine 2>&1')" + "PowerShell(cmd /c '\"C:\\\\Program Files\\\\Microsoft Visual Studio\\\\2022\\\\Community\\\\VC\\\\Auxiliary\\\\Build\\\\vcvarsall.bat\" x64 >nul 2>&1 && cd /d C:\\\\Projects\\\\CLionProjects\\\\ANSCORE\\\\cmake-build-release && \"C:\\\\Program Files\\\\Microsoft Visual Studio\\\\2022\\\\Community\\\\Common7\\\\IDE\\\\CommonExtensions\\\\Microsoft\\\\CMake\\\\Ninja\\\\ninja.exe\" ANSODEngine 2>&1')", + "Bash(python build_anslpr_devguide_pdf.py)" ] } } diff --git a/ANSLPR_ALPRChecker_PlateFormat_Guide.pdf b/ANSLPR_ALPRChecker_PlateFormat_Guide.pdf new file mode 100644 index 0000000..5ef51d1 --- /dev/null +++ b/ANSLPR_ALPRChecker_PlateFormat_Guide.pdf @@ -0,0 +1,257 @@ +%PDF-1.4 +%“Œ‹ž ReportLab Generated PDF document (opensource) +1 0 obj +<< +/F1 2 0 R /F2 3 0 R /F3 4 0 R /F4 5 0 R /F5 6 0 R /F6 13 0 R + /F7 15 0 R +>> +endobj +2 0 obj +<< +/BaseFont /Helvetica /Encoding /WinAnsiEncoding /Name /F1 /Subtype /Type1 /Type /Font +>> +endobj +3 0 obj +<< +/BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding /Name /F2 /Subtype /Type1 /Type /Font +>> +endobj +4 0 obj +<< +/BaseFont /Courier /Encoding /WinAnsiEncoding /Name /F3 /Subtype /Type1 /Type /Font +>> +endobj +5 0 obj +<< +/BaseFont /Helvetica-Oblique /Encoding /WinAnsiEncoding /Name /F4 /Subtype /Type1 /Type /Font +>> +endobj +6 0 obj +<< +/BaseFont /Symbol /Name /F5 /Subtype /Type1 /Type /Font +>> +endobj +7 0 obj +<< +/Contents 21 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 20 0 R /Resources << +/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] +>> /Rotate 0 /Trans << + +>> + /Type /Page +>> +endobj +8 0 obj +<< +/Contents 22 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 20 0 R /Resources << +/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] +>> /Rotate 0 /Trans << + +>> + /Type /Page +>> +endobj +9 0 obj +<< +/Contents 23 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 20 0 R /Resources << +/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] +>> /Rotate 0 /Trans << + +>> + /Type /Page +>> +endobj +10 0 obj +<< +/Contents 24 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 20 0 R /Resources << +/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] +>> /Rotate 0 /Trans << + +>> + /Type /Page +>> +endobj +11 0 obj +<< +/Contents 25 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 20 0 R /Resources << +/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] +>> /Rotate 0 /Trans << + +>> + /Type /Page +>> +endobj +12 0 obj +<< +/Contents 26 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 20 0 R /Resources << +/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] +>> /Rotate 0 /Trans << + +>> + /Type /Page +>> +endobj +13 0 obj +<< +/BaseFont /Courier-Oblique /Encoding /WinAnsiEncoding /Name /F6 /Subtype /Type1 /Type /Font +>> +endobj +14 0 obj +<< +/Contents 27 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 20 0 R /Resources << +/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] +>> /Rotate 0 /Trans << + +>> + /Type /Page +>> +endobj +15 0 obj +<< +/BaseFont /ZapfDingbats /Name /F7 /Subtype /Type1 /Type /Font +>> +endobj +16 0 obj +<< +/Contents 28 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 20 0 R /Resources << +/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] +>> /Rotate 0 /Trans << + +>> + /Type /Page +>> +endobj +17 0 obj +<< +/Contents 29 0 R /MediaBox [ 0 0 595.2756 841.8898 ] /Parent 20 0 R /Resources << +/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] +>> /Rotate 0 /Trans << + +>> + /Type /Page +>> +endobj +18 0 obj +<< +/PageMode /UseNone /Pages 20 0 R /Type /Catalog +>> +endobj +19 0 obj +<< +/Author (ANSCORE) /CreationDate (D:20260505042154+10'00') /Creator (\(unspecified\)) /Keywords () /ModDate (D:20260505042154+10'00') /Producer (ReportLab PDF Library - \(opensource\)) + /Subject (\(unspecified\)) /Title (ANSLPR \204 ALPRChecker & Plate Format Developer Guide) /Trapped /False +>> +endobj +20 0 obj +<< +/Count 9 /Kids [ 7 0 R 8 0 R 9 0 R 10 0 R 11 0 R 12 0 R 14 0 R 16 0 R 17 0 R ] /Type /Pages +>> +endobj +21 0 obj +<< +/Filter [ /ASCII85Decode /FlateDecode ] /Length 2672 +>> +stream +Gau0E>?BiE&q9"FeC1!C9oL[]')$>UbJ6g?dL?;Hh1s7H3Pnf0G:T!2(Ee)#motqpa)Pq90KksR=I)odWlq;9_?(B8QMM*B!.UTVq2GOnJ_:)Ua)GF0$eM_KJ"9^'8Codo@XA6*a##-7BAku>`ed_BMg-p["!M^Uq$d@?,/kFs@p?AP#-k)Eo"]4XM+;qaQS?#Kr-3Sg!-*K5FqU6'4rB]r7eBf"=^g5WN0bEpd`[^Ob=WA9caps22"/WK]S_Lf*%:ho+ge;SDWji^QG#kY(CS9Vbs67:6@6,73#[E5qir]IfA\@B>pb@0ro(CM#>)5)'!%Bt'p`=0'38Z@79kYR$Kr6*pj%G>Au5IQNaC)V-D@_*J(FoQMmkkt'tJ@t,!5j\Zbe'0%jgBaL#YttNr'scLBb$ZZ>"[We8CDN\[neV=(*3t7V=.DW%Z@&1<,%+Oh`Cj;eRMRErE"M(\#%`rE;8P<(pd2[LGsUa9e^A[)#Ml:5G!V)53rEcV'Bf;bUS,pV/Y_[Oao1JgR-3&h\,^*iPMQ:-YNZmUjWLdN@BtT"e^#m=bKXN*1AQS>]R$groeZ[Vt:\h<5fMrbs2_^c=Lom:So1-"sgeGQKEV.]tm#AkJG6>jl#auFU/Y>cM$?B!T)$Pj1SB9Q8ip8@!Fn)o9Wm!b3,d:msMT/N%"p?>L2_8P!`IKY(_-nIA@F3pG8^Kio3Adpej)3af;[UY+r)rkbT(fMm+#%OYZ)Uf"mEji<%YAM^Z@%5Z#@&#HPUtLVH=lbZSj%E0$Z9G,(UGW@Q)bu`j5.!H$R%!I?,aVs)'Q0DYn8*UF0&_kc8:tOD[og','[tIXX589h)YYLWR?Z6r2>k=#=f>&(f'fK`;%9,?>fqT^DEOdnXc0i!>B=F=Cq`68D#@T^8NG5n^jd51Y(X,UCMXH+FVChc-@K`npb-ucE_2Um4RiX]iE+1fr;XI]ShS&PS*mC2fm^t)AS5tYLg4p&!J'hHLmJ0MrNgXOn1(?H.t9KpUfOq1PE2(o-_W%=VTpb=eH+u/#5EmE)AejYaLD,o16:gqokXG!YQ4Y/b?qX&u4LT&`@=9kSi"I4lX(El=B%$R5jf=tiOk>uYiu[_3dF[YAGR0r0Vb!A;lrc_"F;2E!O(I/@Yb#TTj;f32V;eRYR8G._]7F`<>ece:7+u[DNkg!7TDnQSqX8A5`oh-U+Vendstream +endobj +22 0 obj +<< +/Filter [ /ASCII85Decode /FlateDecode ] /Length 2090 +>> +stream +Gb!;dlYkN9&HA?:K'4R0W>.QIfhRk7Bs>&&dPXb3%RXM)MF:Z`A5T2e[,/%eIA_iH*A'p!*nUZ?B)"FDj*/O*C.*bO97NKY+YTbSk`nUoSP837)^keD4XWHgpV-!.q+>_0R/51:aA?g)0b&%d1Lg$?%[]=XX`n@$=/1-kG]q`53:Sb^'l_,_n?]+%AVQcLuG`Y@)0SW`@&.>/CW/gB7d/!'qJM?%^48)XRa)56-$I@#pF9FAko.h91HCgko2YU)UYXBNcTV`G7C,-Tri]j"/XN8CgbQ(6/?Z2CZiVR_Xn)MMBf\rTt?/QS`S^F5Q*_odoc)kFG+5W685MQ=2M]A"920N+IUV_Y^6+mQ\NA$li9[QD&8[10[pQ!F5'FCH,+5IYKp6fD;f_)=Q)ilDnL,h"M/'914^!F==f2WX,A,kp7ud:2&U+*6_KGjO>8lfCacDeMEpo\Cj/'J8@\g3_^HgmR7+aq;lpcoDE++Bk=HH&Jb.^EkmT[lS\u[J&6ZPrj3-QVc)k%TSINoXK'&SjjiXie3WPA8KVp:b/$8KDkb:b9qJT2*TBLH2I6/j7;Ju$VpR,Pdr45?G2YP;O>I%1o(7.U:N$4A*64)64?&XX.K%),=E]^'a-)8)b&Dqt':Gq\JGV>3P@Pk:NO3kk!s=,;&:8ZD7[SHNCkn"1p)Ec2*1l0$1D/Z%eF&"&FjJ1!)'Nin:S,!lf+Z&X7n9Aj(">:E6fJZB.&-3R.8iPB2%?_q5XP&,R956^DltS&rZ$M;eUQMi;8LZqG/%WM"l6Y8iP?0(kL)TrG/Zj8$1,3$$E8t,I$Z-u0blPhshq+?MGJbkEB=aA@?\qggGF_tZ1E8D$rB=YrUKV>,U9I'rq))pm'VuA`U?agPTd]i=;sA_NK_0_5,+\Ef8NkYHF5'Adq=gC(UGc#mZ35MmH+,s#4[M3V8V5Trp/U\EA6U;OTh//,p*8X<*@DINN/,U-iY=O3>9i:*ik0gEfZ"kOQ*h1VqZh0:`3f~>endstream +endobj +23 0 obj +<< +/Filter [ /ASCII85Decode /FlateDecode ] /Length 1874 +>> +stream +Gau`T>BALX'Ro4HSEU]$MM!Vpa=a#t\kT)$[[36#9Bb_%[K%%P;+X$?S_`2;8$Y]GMRdgBg1I3#*K-\6s$#1m.fT8;s(DIQhLh""+8d&L#2n+H3qU#QVH'\^YJn3i;@lb1FbkP<`ccG5Ad+&h?85`(j9p3J/&LZM(36BkWO\V*'s&J'/+_u[ZQrR\mLaS@]=7.8"C.Cc@okMs+na&jsQ!>34%qe4P7++WL&ESbi0\Ue^U(DcKnSUE^I4$D^sS(YM]@@pE\3DR1bYBm\A"[Xo>5FlstW@\:.iC$X2K+<(KJHWSiZiKu\qhd;4%iag?Fqm'I>QS77qEBpBTBO"kV/#J)h4+T6r%Sc+NrO%>8iqo9_#!3fV3petra'<.">41D.37c;HOJN2QVpbVY6^&h9n9+M/4e>"GXobBi5K+H*e54CQBHjpGQY$,6egp$rG;H[k^hfZVOa$Zo>EIh7VmCf<9)M\2/3cA-s]MOm0Hc!t7eEQX=^V;:ZcdGU]-Qb1\V-;F<$*m1LWoB[?Wrc:9LP'F&j#dXNH=,_lCkGL?CtJb(B.,Njoo7&HGbEYVu5*4q+9T:#SPIV0P,ohud1;V8;5Z1Bg.C+k$HLYPJ<>E1"\[=7tK$PWVXI>5=>j#FLg-(m>f6&OV1\O^btsl8A,]+4O%ONu44V,(qYs!a$;!+MnWNYo1?M"S`^b+KQ*u,^auf$*iOn%>1'8ZZrK,$Y.7^g0>\UacopMG/lLS"UF&(%=]T=%dL[9E-[_N$d$,$l_1^AG9N2hK?L:XV0``Rba9to?kJM!nJ4LU(n-,erN]3<)@^c7os#Jd[ADY5FmFXOOg!!d1D!\iY4LUoc+h[UGMFYB%@tIUWlFXI\QZajc\uS3_dlEW`cKHagj[s^Es9"RHt&"`J?FSbWaALrKPun6:/,?odc=pC`)1_fD8sk?Z["jWio+C3c-(H1crnGNW03XQhd:bK&S5h73oZYRd,g?Z#17U&.=]uW=Lm\I-/]^CiOr3]OOsNaTc9V_lj>RCOC4P."!)t"e@ZlY:7k7Xq?'RFm##"0HZ-q_HJnfIk1,m0g&C(o9JV&Ph"X;4ZPHttl7Lh0n)9`V"+U+n8?B"r`Zeubc$/VL,^/"n.56+HecTI38X8;Q1e_QlR>L(q(*#BBY&P(Os,lCTJW0k.ED_[TO4W-/rHT3QiM<&$I4*WT93-pR!Zr0^`<$mg:W)Esh#;,XpS]^Z<#q:Ks>#hR.MfU]ojF4F+HpBe1$8d4-R6c/\5RmMN:d!d?g7(4BO:Js[M$9sTYe7oUo8#OP]Vdf~>endstream +endobj +24 0 obj +<< +/Filter [ /ASCII85Decode /FlateDecode ] /Length 2426 +>> +stream +Gb!;eD0+E#&H;*)Z.#+98/rE__X7nmXEE:E,eqN'+#iJ32h?d[V&U0&@JVO)M\i68.S.7_g%mLJ_Y&te:DT<&e(5Y[kC7j9\^u&0W9(eSU=^06A+j`=kL6GG.s4$iNR+.4bu,*96=$WiqH.^)I6@T_VZm&6HW;?KtO3E,k\`/]&cgBrkPQl_n`6/C;'QF7-!C.uO[s%e71]!)Y:+qj!OMsO*+D=Z]D(C>j,gpA/CToN6XKMI5L2bf+[nIR>Hum!3ki:*l=f5=F@I^1YFc[`G`"dYFU!t;a]DJSi:8^eAZ0h+b/7GsN8T`QcG,ZPo/e?6Mj?qa[Vu.cr8Otj)%Gb\9#FK$l$BqRmHj$r7K^L>[F%\io%JWL@@T1dF','MZ#Sq6em'cW`'o`M@WM>.0TKJ']"'i2@bl,b^+f@q1=oh5N*fPB@dUoDeAlApl8u>!Xd:YaoGhb.j=3N8HNjX`6LSWe)\Q%Lf]8RY7Ogka/_E/AaYF8:3!:reV+[lR:M+1Q=;aL2-1!Fe\C\At9j%&K3FuUF)etSFSr1@7E0pn'uQ4RuFS_C`;d\HQA&W0_/QI%9.q_fs;]4`PNR92I<4>m6.J1Qba6A`1%A/93)-Wkh'eNAquMn<.o27PrD_:&L[]MkqE4MOSN!F8)cNWJ=*:hl)B7kc)+#k53m(Tj%*A%HE"f"92\L;0e?`2^4o5fTI9TjH$^/uEP8`!\!V>;T."cFrbDi\l5NY^?gus2tcbdO#rF3i/r%/=4j6ZN,2/nmt($[$Ngl/kqN^^L'We_Wl:aa;QQ%`YU$H51bu='?@>Yh=%6nZc<>X'"HJ[L=FO^R+t57^N@Pn(hc;SG*M_0PFW\Kr3-UZNF>d9(e,!f`*M[I88H0l?8tf.FPNOS..Q\#m@WJ"f%I;$ejYD=%7dL-W#'IbPA+\8u4'7elkBLtRWmrW+k<=!:#2*gkX$?h@&!=:0/l0_.OkuM"3Z(689ZbH&502b5AEVO_(4l'"4#$Y4l*?5]`DZS1;Ej+?f0.%9\'.%5eum\KCeTQR]9P:VD4'L3G.L@kGSe/\RV:Z)CH54QZteet7/='^NB>;i>FVj`':(ObjV)78Q$Pnp(H7$LD6'KEQ*^;TD"=q/^tsPFO5cH~>endstream +endobj +25 0 obj +<< +/Filter [ /ASCII85Decode /FlateDecode ] /Length 2577 +>> +stream +GauHM>B?Pt'RnB3cr98tX9gh<^"_dFP4e7=9m9OV]:D^GaiGT7)N:U?iclRAgNt2"#)k9[g;Xe5OE:uqe%'ir(eBFKU#*I/6C1Vmrn]npM5G?)fU@es2eY<:qs2JIB+@Db^iTekHuZNeiu#!1L,Ieq%*M).BoPg(6/'*l3i7g;E#-W>_]c$Z\jH4^aYbRg5f5=hmO__C$a`hHp2Tab1,%S30[OpSe7^:P\RP$mX=dIFH'0%,tG$1't!=9VQ1PNdT+,qGDV$_!*+u&1l0&QKHUjr;$["o:c:mTIMf>>>;1kd5]./?8fMn(af43K#IVDHB5utSFF6?fQok^J6WOSYe,GOSn@@U'KaF=k.8`YJiV`Be,Yom$T\@KC'phK@E7u_C5uf?#TmK`/'>,gXDulQW!i^IXk)=BanuLmkY%%QlPjc29-6LN`QELX!^"cLSq(k?]"e/i\;`<8"ljA\^=1/Lej9@W`-+u'?8C4C>H;/h*$6XM;9ij-Z57=$JWFrVA9dkIUD6p:[mHs:3Wa?g!T:;NOARr.gE%3b*>9iLWJ@usW.g)YT[nX&.sH%KOm)R5H0)Xumhe7_i[ULlRVkO*`?A9gVSd-@#S,M(:iH**kdm/%e$4j_`B*i)a_q_f@'T.'S=Eg/h8bnhZ]psb!X_b5Sn`5>E1&U>R:SWCd4K`VU4+r6-7_4i@7T<9O:7($.OT7dQ%/A#,ag77saH4\PcMJ5GA_7a4Z6[lmn,1cYaD`VIQ4f2.!R"mb7F4f!2*pRC/_u4C]07?*ge_VYqDH8@dkZ7/0`ZAQ.LX+i]i=j(BP_tRRjYqCE\pcb!SLVVem),%D033bEaJ88f%&CX2kCUiU\9o.>#pWht51m^ki6o5Spm<]e%UHcTYs*B$G;`LRO=6:tI-@k7IkJ+mM#+Ch56@P-X`_ANjN5N(!GdLV.>78hfSW)'Q1,cY'W"lK/5W=)bTn?H1M$IaR]mam/^io)%W@4CI0P+';"ATjZDA8V%@YqSaV0B6aQ'`cg+e?=]+(32@=\VCL'8r=*SdV.VLgiGeL+9f;l&Jg'_6$l8`PS8Puc:WEnZ&OLP)5YjVnPF$M"F>!"bkV2c\HGWMdP6@U9:=p6Mha2(1U+];*e:Jn=-)((S&\((a^<2a"+a!p)*`P_j^cY"tF66_$gr#%CJn0in&"-Yu$?oPuU<]'\r[ENg.RGYti7VUNrq+*G.A-"p55n(:_oRPm(6$@5:Nm,r091W*#k;jQ>A2qIO.$E>9,2'jINop'IX,>tM)Ke;a1U3t$I5-^"*7&`(37si.N1jhm#K)`.O-cQ%rUm6eO..R4R+mq^Zom#DBILV2>(0Nj33STsFKjhVT#R!a`;'W^&GA6'3FuHd)-ljVF$c9k[20`!St.4iI7](oaVJ>,8sZ+cCo_VmOuH\K7".8M"c-):CVr_OB(aEHX.RE#?DGWP0>G4j5@8o->YO7UR"cRtg;i`eDi9RgHhNnb\bkXf[_J+#AN[MPs4[qF>WZ%a&!-3"Vj5F^j2DfkNVq,89W0a?k@kY'Zb#o7NH(Fl\*;GH_5FO?manUa&c1bd?&/FRNe7D#PaPQpfddk>BgO3W--rLV6"dAT0FpI;:f0$li3Zd#nLQChqO@*FXaq1L]m29&[:ipkbQE*fFn\`!/jl[.]Y/e<.)].;BB)HX0Sig9LK$i]+oC%#d[4D"5n("2UN>Oal?7`4ZK^oDe^2V>bl8>CE6Ins?/IPSK0-`ZtCVoB9MU)2%m(5GW~>endstream +endobj +26 0 obj +<< +/Filter [ /ASCII85Decode /FlateDecode ] /Length 2659 +>> +stream +Gau0E>>sRl&q9"Fo\5%)0U@*Cc.70]!]/"8A/WJ4_l6V+&rmSe34@F>\87]XIp2D#[M,.sScf\LP.kgV\%=jR"E]#)p$&RZI\"=.B**b'C^J&09UOYOea2MG,Ee+p`gTX3S&3gTRUb(Tk@$;E,UF5O=p(UAmb)4[`0"`%DApG1K16<:&fW[NG&03oA-J_iQ3a-;VqA]kR,G3-Ou3pB_?,5'KHGog0`(mWT;45Ln_L%';-.G?\8>L\WN4Iq:i!M9eg%1,\D&9KPk"j,Fa]T&LojfXJ-6_OeYX@MM/!4:Y^:dPa;Z\:*>NmP(!ZnM_;[Vhb=p,[l_l:KL*kS3HFDTW<;1"\d6TIqd^`;)IV7Hi.eAT^bj\H.3ht\,0X:N_M+dspD%+*c<:idYAA/:BqqBU]:iSr[A6h44>.]:X:Sc`'?Q<9d,&P+d0d4BV+]/,^H1u"iZ3<].9F7`4Dl8Y5HS+\#X;gcNQaCRKc/Rgg=K&%hah#Jg`oaH>tDik+3XXp/Wk1n7O'245jJ)q'*O/hiI&ra!I,:k3cG3)ab8.Cq.pD^DNZ,KW,L.oSGr7k)5R&,a:9>oHF4f1'cm!KLL#%1$*/2V/*jG+4HQA;Z;HIQNfc>-p6Uc5s6D:`A'p0.G7H<4Z^^V#r#"$WDdI9;C?'*bqNfNO[>r4Q62C]EN=G?o^EAJM]7F=>"[V:"UemZ'@tCe$-*Y$sWpK4XJN%Q^/iJlIM.FNe`u82*0'7p5Hn)'"/o!'h`k>@I#$&n]?4D"-C$IEnAQiBu9gl0Ld9U04+![M8/kJ]'6,9W<&Y^XMmE2`44+I1Z0]/pIZsAUWGrKG5&hGRuB1":P#D@&$%T(N@>0SEA,NcmOJbV?L+B)>uMk!jKaYHgJ9=!"8(\@j`-fU[L37Tm\>F(NQ\lXY<'':EjCe58GN&Nojgt$?*'T2,f3F@E(q_O&FeQt`c8Fb441&WlG(C*Q/X-e@@`rellhiTV3_EK('1_J;fWq+8@FUa+b@%0"kZB\9#:lM6>TVTqna42Dnq\hUl?7QTX[!+3<[W*`/jH=SYO.)*]hWKnJ0eE(KN'jbZ/fr`%[L?%P"_V,74SG!g=:MReOuR[XU_]$E8<')U_:XhV8Ef>SG2KJcdWiRW?o>mJm/Xn!kX;n33^/W%*e5-:EpEU\F>$-m\IVT![9>b(Q.;7t#L]%j[C=?`sKLp5ib8A!d<;/P5F`*::(s/E30Nh%nJSAiG?"!Jt1/>^b"NHQ?=_T0@.?bBV#q1pUkARJ5C`sVCi)s`/>]j<&5\rDVpK\SDT\E[4-OPgCobmSVa?[_`\a1h:QEk9XFFfGmjfS%(UWE>80hhodH0&(c,&\pg:,9r9:Wn_<_YEWVGC&$u/Tbr&gVH^Id5]q/R00thmppZEC<"'j;H%-j:K9hj-:8FpddWf@EMT!Smed8,%4)RJP&KWB?=j)SORV(%]foHU`_.R@fAZMiTYQYMib(4biNnkr"g_CjiIm:5I6HF=7GO2O5C7NTl-bWDHm#bqCCEUT%IlXQCDH#o`$/m?I+]4k,BBSjs+Cb+!EdpU^#mrd1OF`itfS=1@IlSZ;Db4A.NRDX3H-K4]l[4H,N2V-?n&DIa'e:Z9,OAe[]"M*aJX@1O&pndo'5AYdSendstream +endobj +27 0 obj +<< +/Filter [ /ASCII85Decode /FlateDecode ] /Length 1317 +>> +stream +Gau`Rd;l!?'Rf^Wgt@H7aZ,/'KRdsr))o0!]:5\Nf\7e"F=>3:3uD4aPKhud+M]r;N88Xq-FVl*k?]07F:J>Q/lI)n.tF8SE.1B/:m`ne0Z7@J%3O`-^IG"=Bt;e99:,6N&YXOVg2/+^]8X*HK6sm8'KOE%uEseo22IXG,0sp%!r^bkeZ'J4E%VP%k&IcsKLBIOqItW\Tn%oDoq3jgK4uXF2@N=GEg;$Gij2AKY#hq-93o14^Rl]K[W<(\d,^@Go6]l(udDUN&O8m9p@)?8B/QJV)t]<11F!FgR@fUiBEhj_rRHZ)+Gb=ZP_BK?>dF(LO%c$ra_,,,kA%,2'miI9mcP&+G@]"$=.70"`UT@(KZ7cXj-N@d.a(f0!]fp:X'e-=g.9L"%8Q"+6G$TJ<`1VEV$[Y9Utk9O&kYWc$,3!M"XK%X1u!V)qJ\DQL8OEIJkCX9dcs!:N%iNId'4*C.1'1dgQ:$9:0[B,a[1dKle`.U_ZIbUPk,fDCb5;;Y>QI"'a92T!u)<,!nc27@p`BfAGioj'BH];F*9jh#[:inHLcb?Z[Q64Yfbmr%SdrY]njOFPRLbs,8&$d?g?Tcd1-:p'Jd\`R]%me+>ii6oLHeLh.Z`XA?q]hLa,2"01s3SDMJef=,sRW,kfX8-:8$1=a]W*(48;70WSo00Lm=b5h)I`kggkJ_rZ-3LgZej$Hu/TdW2i_tEgT^A26ogD^p<]uc%NgYF/5\\-03;L>U[GE]Y(P(cc)8%b:/A7?;M8X./+R94g8P,4fk;s,jS+OGP=2TD4/Lk>Qn?2,O9QeqmQ%[J8ID(50p'Mrc$&2j1Ars4F7Nm#"uc;=r>;WXa4hc^I=t&ea1ZnOj5[ahN3e(qY9)?Tp_lE.eS'[SDOA7G_hkidEOW.V>_hJeQDJpO:KH@hlS'4-)j88-RjtR(+cQC)V\^,V~>endstream +endobj +28 0 obj +<< +/Filter [ /ASCII85Decode /FlateDecode ] /Length 3004 +>> +stream +Gb!l!>BALh(4Q"]30fiH)'eI%JF)]VmFX3dAWi"sAfm>@WCA_kM,8!!,maD6pRINL[C@&8PHCgQ:pI+9S3DAhhn^ADq!lSSGRe[UJBL"b4tAmBnP$%Mp5Ps(>q_`Q`1S##H8gh>/fB^o$`6>j7+g`rk4ImqJE@NqO?s6?&Ai>CpjOjrhi.U>If7]b>8(*L]O&>cR9,7sJ6l/b\]b9UCOT]0cmn/()Tb+.EuMNBX2dH+[gtFlf"9qQ89/R,Tu?=UEbTtGOgSXY+/*D-GE0#UH,u8l5*FX&<%]LKcLm:/[hepU]tHDrp>__P&'suU[sD:c>-C:XE\3tjhK@Gu/]HO4[HEX(fK48<'c@fZUk/OqcmdL\6J)D2C/=-^_?f-61Gc*bE@W'r;_?8uF*idEO)peKs4r-rFe5aYSQ0.O'bYucGb)CY\;-=@Ar4Q!(gD^$8F[*)7r6ocJ3OZJ>DS*;M'AM#>Oqr,n11j4NBF2D$>*36aHc+s$4`Uffilc"e20!],*S8a3`BsUH!r/8(-6ZE@E]OihO[92aj"oj%!2S=L?,W^jc.k71X]2;"-)^A]H7Ps;:GDQ1#WU<+EWfhc&B41B3?pc;R%du6$L_HZYHT&?]^s7`j$.pN?ld\8*prf-]Aj\K6.4mH]$XQ320-c::8jBg*O'(r1&I'\qkDN;[9J@-loeU]k@cK6stkq+J]tn#V+F/6s>aU_]U^iV+;4Q5nAdN&n)t.r`l+Hb&PB<-/YhP/qBd.80u>$cO(me4r9Toa)k5$Le3NMis$,ci?&?i]5T!Q1fl3Gd)[Uk,!(:3^cqt_]uW\6_(Lm8:rR<0]>ikU5%=s7jB,)&W8^]F.,_VpGt>KCApW"AX7m-Xid\T9peN9_Z5pLmLUWqRpM[<1ZFT5mhEAdJ,HV&QjEEZt"=UI;e="`K%n5B8*8bs%d.Til%8:(P;>O7-HG/$q^os&?HOV8eVr,CU_Y#6dA@nfS2$("cjft;sIE,MHBmk;K4*Z8JbMuZ]gjP2]\rFI=J2Q%f"O].3OgJs*dKOHkNQ1aVAViZJdD`%\UNS3/*0iM(@Hrm_>@(-oB?0"Vk]\44TN2`^huZ7FBmV$GpOl>t'5fo?(V-(lAId$\E_4*#?dtYO2Plq+2tP6G,ho1##C[9=!$QS*;c"X/]oEJoqddV>5T-SZ>,!L,NuCR!Y=%#.C*30SI8Nq/1/*fSAko7k@'g(%0Yo%u4pu`f5/eWT)6V'h7KFSXM-QdnPq8dg^_A]DiVB'%Hq`=,<^Rio)0a:PX@Vn3]lD<+\,RCTP"\/8?mQ3%A6,(@/Z-lT9+.%2X,T]X?,q)7DANLM/1E9Bb)(S^1bU&_rd@N0f0d+*mmRJNp;S;OFh(Z+(5HrJ'c]B;_*/9H@]e.[:-KAgpEWQ'8]`aq+&/=J3qq+0Vs!Km\JF:EoF/TFS`=[Ej%%S((Ih3GSY^C[k(gdq-;6RXISKcr&*T^,G5Q"#^OAM0p\aMo/2&O,HBZ*+_h>Q6`:H[n+7AP<(QEXG54L]2o$BO(RQ*ke"eh:"@-PIR#nrF5h_bf\O3Y#[[)8::WD5lZ*-oSoSn-M7o<*u/V\)7A-F"F9%N&u,Lo?O(6M&L(kPP:&uJ6)!f4X.E44-moEt:R=E`=YVuWh&0\f/1-0_fqr2)AYf4p?r]C.R8asbjo%3Lk4.aK5Z=o$%+$N(hhf]>EL._R7r;iiHc!d^`u=DnUPkY&1D>.4r$R.IjfX5Wk/^%oA1Y.&$bEJ!*7.p:9,CMpJRW-_9Hq=/Q3og*]F7L9tnb"FI;5\F*$dPV7q=5'C)7Ho'\9k=Dr(MY*/KS%RoA1B9N+XOhTho4\QBuCU@o"CaDragQQi%ZTu[>^CUrgjV7V\AX]uURl7UY\ag[P$=NT&C6@:qu[+m2p:g2EU;'f26$FdsPgo4)[gUa_,eXbN01D*e1LZ,LiFMiga$]SlJm/$JLm(m]W'BATeC=b95]Cu)k#3nHKV[44W1Og'jW+i`'H7dNH-4-.cMP\(Z6$pr!kgS=o"VGpO't6&iTRGXF`UHXp8cp]*QZ(T^D(Nl'7!>g1DMF*mSKLgeI.1B4lJsNViZ6"mCD8pT?m(;(9GG`qF.`he>p*J&\7oLk_BagTjlPCK<';kL1WS^K_\W+5P)0XRgMi85oa,bTF?9g,CF5,`oIep0g9#Z[p;,G^!&L_t:&~>endstream +endobj +29 0 obj +<< +/Filter [ /ASCII85Decode /FlateDecode ] /Length 1756 +>> +stream +Gau0DD/\/e&H88.ETi2.Bk'T]S#$9+O?,tBU1i#ol^)l&=IHVI;D4=!]%O=f^*>)KP3^2LJ_Go+nP4<&g`):t@,dNOh_5(U21a4l!lT]4*/J)a0R4%-PG>4"XD>PI*X&4*g-u]Z&(UF_m0B&G[S%Qmo^k`(.Td:1hpio,cJQ]@Oi1b<%tP8!617E<^=L<3+q>-9KpATL"-&%^FfD8iE@JX"4oI*e">WHQ>M1/ndN\s>o6`TWe'sR'IpjTO6O,un-.'H"B(Hn7\D%GJWHh$qCOJng60]tP)6f9B:!.U&';aO^h2KW.G/\OOP=bqo26gB9!1D_hYJt5^d:mJRdF1bjA&@bi,qNbUWGiSOYLn4i#p-O@,LRW&5][999t#Km>ck!cKu#()dj5flA*3ABAM>,=F9V-R\*t$m=clM]o9]ndS3WOnAdlCb,#/s'j5'2r?tl[QW"!-9^:,Q[X7uYL%3p3c+][)oE[dA5I+C9qWcj!TjP[fKL>5kmtnp%FFGpO^;[:c%K:jB35s=JUrSS?jG`OMP$\p@i6u_\eIQTfn+2\#"XXOp#T_lGkhqgRIn^Gk?Q\5p]kSnBA3DQe7h0a#A@;eVBA%)U[TFR_,U_;(#p3rG**ZVmq:Lea0$.smln6CtO[tg,eg)4o>82Ib$!rDFXU/:j1l-+0dIEQZRthpPLWsY::F`NXk=K*cP6s&'18]sd.n(Fe-XSEHl!CYkb6>?O`Pm4-O58Wm)S7",b$!Oi?hlUiC?g9@6E+h\n\MBoK03DK&p#4DI_nj%lt^I&^mlA(qma5M`'X@F6FCgr\.IZF>YoR4`9C/R""k^R(K&0'lmr<4"<@7_S-M(>OTrp1>Fki&p4Ui#UQ``pO;^QRJO#>a&muFt8TGOsbSFpjO#ALAZIq!$Z[0o0[En5JrD/sN%!^B=<0)?Q,@7gX];JSEodXp58VH4XQLRY;4QkoBND`gf>ho5X["N7u(Y:`**f@6+S*`jN0KCc;#P0XDklUgB_,_1O+ckmOJLjRX&Cn9Q6'#tcSn^^E`V;AQ$1n)0'A,pka6BX5l'HMlrc4@0n]d[1dSBl/GEZUXGs^OjdPjMt8,i[4M:L#~>endstream +endobj +xref +0 30 +0000000000 65535 f +0000000061 00000 n +0000000157 00000 n +0000000264 00000 n +0000000376 00000 n +0000000481 00000 n +0000000596 00000 n +0000000673 00000 n +0000000878 00000 n +0000001083 00000 n +0000001288 00000 n +0000001494 00000 n +0000001700 00000 n +0000001906 00000 n +0000002020 00000 n +0000002226 00000 n +0000002310 00000 n +0000002516 00000 n +0000002722 00000 n +0000002792 00000 n +0000003108 00000 n +0000003222 00000 n +0000005986 00000 n +0000008168 00000 n +0000010134 00000 n +0000012652 00000 n +0000015321 00000 n +0000018072 00000 n +0000019481 00000 n +0000022577 00000 n +trailer +<< +/ID +[<413842c5e0047711ecfcc107dd69f293><413842c5e0047711ecfcc107dd69f293>] +% ReportLab generated PDF document -- digest (opensource) + +/Info 19 0 R +/Root 18 0 R +/Size 30 +>> +startxref +24425 +%%EOF diff --git a/build_anslpr_devguide_pdf.py b/build_anslpr_devguide_pdf.py new file mode 100644 index 0000000..dca81cc --- /dev/null +++ b/build_anslpr_devguide_pdf.py @@ -0,0 +1,850 @@ +"""Generate the ANSLPR developer-guide PDF. + +Covers two features: + 1. ALPRChecker — tracker-based voting / text stabilization + 2. Plate format validation — SetPlateFormat / SetPlateFormats + +Run: + python build_anslpr_devguide_pdf.py + +Output: + ANSLPR_ALPRChecker_PlateFormat_Guide.pdf (next to this script) +""" + +from pathlib import Path + +from reportlab.lib import colors +from reportlab.lib.enums import TA_LEFT +from reportlab.lib.pagesizes import A4 +from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet +from reportlab.lib.units import mm +from reportlab.platypus import ( + PageBreak, + Paragraph, + SimpleDocTemplate, + Spacer, + Table, + TableStyle, +) + + +OUTPUT = Path(__file__).with_name("ANSLPR_ALPRChecker_PlateFormat_Guide.pdf") + + +# --------------------------------------------------------------------------- # +# Styles # +# --------------------------------------------------------------------------- # +styles = getSampleStyleSheet() + +H1 = ParagraphStyle( + "H1", parent=styles["Heading1"], + fontName="Helvetica-Bold", fontSize=18, leading=22, + spaceBefore=4, spaceAfter=10, textColor=colors.HexColor("#0B3D91"), +) +H2 = ParagraphStyle( + "H2", parent=styles["Heading2"], + fontName="Helvetica-Bold", fontSize=13, leading=16, + spaceBefore=14, spaceAfter=6, textColor=colors.HexColor("#0B3D91"), +) +H3 = ParagraphStyle( + "H3", parent=styles["Heading3"], + fontName="Helvetica-Bold", fontSize=11, leading=14, + spaceBefore=10, spaceAfter=4, textColor=colors.HexColor("#222222"), +) +BODY = ParagraphStyle( + "Body", parent=styles["BodyText"], + fontName="Helvetica", fontSize=9.5, leading=13, + spaceBefore=2, spaceAfter=4, alignment=TA_LEFT, +) +NOTE = ParagraphStyle( + "Note", parent=BODY, + leftIndent=10, fontSize=9, textColor=colors.HexColor("#444444"), +) +CODE = ParagraphStyle( + "Code", parent=BODY, + fontName="Courier", fontSize=8.5, leading=11, + leftIndent=8, rightIndent=8, spaceBefore=4, spaceAfter=8, + backColor=colors.HexColor("#F4F4F4"), + borderColor=colors.HexColor("#D0D0D0"), borderWidth=0.5, + borderPadding=4, +) +TABLE_HEADER = ParagraphStyle( + "TH", parent=BODY, fontName="Helvetica-Bold", fontSize=9, leading=12, + textColor=colors.white, +) +TABLE_CELL = ParagraphStyle( + "TC", parent=BODY, fontSize=9, leading=12, spaceBefore=0, spaceAfter=0, +) +TABLE_CELL_MONO = ParagraphStyle( + "TCM", parent=TABLE_CELL, fontName="Courier", fontSize=8.5, +) + + +# --------------------------------------------------------------------------- # +# Helpers # +# --------------------------------------------------------------------------- # +def p(text, style=BODY): + return Paragraph(text, style) + + +def code_block(lines): + body = "
".join( + line.replace(" ", " ").replace("<", "<").replace(">", ">") + for line in lines + ) + body = body.replace("<br/>", "
") + return Paragraph(body, CODE) + + +def make_table(header, rows, col_widths=None, mono_cols=None): + mono_cols = mono_cols or set() + + def cell(text, col_idx): + style = TABLE_CELL_MONO if col_idx in mono_cols else TABLE_CELL + return Paragraph(text, style) + + data = [[Paragraph(h, TABLE_HEADER) for h in header]] + for row in rows: + data.append([cell(c, i) for i, c in enumerate(row)]) + + t = Table(data, colWidths=col_widths, repeatRows=1) + t.setStyle(TableStyle([ + ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#0B3D91")), + ("TEXTCOLOR", (0, 0), (-1, 0), colors.white), + ("ALIGN", (0, 0), (-1, -1), "LEFT"), + ("VALIGN", (0, 0), (-1, -1), "TOP"), + ("FONTSIZE", (0, 0), (-1, -1), 9), + ("BOTTOMPADDING", (0, 0), (-1, 0), 6), + ("TOPPADDING", (0, 0), (-1, 0), 6), + ("BOTTOMPADDING", (0, 1), (-1, -1), 4), + ("TOPPADDING", (0, 1), (-1, -1), 4), + ("LEFTPADDING", (0, 0), (-1, -1), 5), + ("RIGHTPADDING", (0, 0), (-1, -1), 5), + ("ROWBACKGROUNDS", (0, 1), (-1, -1), + [colors.white, colors.HexColor("#F4F7FB")]), + ("GRID", (0, 0), (-1, -1), 0.4, colors.HexColor("#B0B7C3")), + ])) + return t + + +# --------------------------------------------------------------------------- # +# Document content # +# --------------------------------------------------------------------------- # +def build_story(): + s = [] + + # ==================================================================== + # Title + # ==================================================================== + s.append(p( + "ANSLPR — ALPRChecker & Plate Format Developer Guide", + H1, + )) + s.append(p( + "Module: ANSLPR  ·  " + "Base class: ANSCENTER::ANSALPR  ·  " + "Affects every engine subclass " + "(ANSALPR_OD, ANSALPR_OCR, ANSALPR_CPU)", + NOTE, + )) + s.append(Spacer(1, 6)) + s.append(p( + "This guide documents two independent post-processing features in the " + "ANSLPR pipeline: the ALPRChecker (per-track majority voting + " + "lock + skip-when-locked) and the plate format validator " + "(SetPlateFormat / " + "SetPlateFormats). " + "They share neither state nor toggle; the format validator runs as a " + "filter before the ALPRChecker voter sees any text." + )) + + # ==================================================================== + # PART 1 — ALPRChecker + # ==================================================================== + s.append(p("Part 1 — ALPRChecker (tracker-based voting)", H1)) + + # ── 1.1 Purpose ────────────────────────────────────────────────────── + s.append(p("1.1 Purpose", H2)) + s.append(p( + "Convert noisy per-frame OCR strings for the same physical plate " + "(“50H 304.07”, “50H304O7”, “50H304.07”…) " + "into a single stable locked text. The mechanism is layered:" + )) + s.append(p( + "track identity → rolling history per track → " + "recency-weighted majority vote → stable lock with " + "edit-distance noise rejection → periodic re-verify " + "so wrong locks can self-correct." + )) + + # ── 1.2 Default state ──────────────────────────────────────────────── + s.append(p("1.2 Default state", H2)) + s.append(make_table( + ["Flag", "Default", "Source"], + [ + ["_enableALPRChecker", + "false (opt-in)", + "Member initializer in ANSLPR.h " + "(std::atomic<bool> " + "_enableALPRChecker{false})"], + ["Full-frame auto-detect", + "engages after a few pixel-identical frames " + "(only relevant once enabled)", + "shouldUseALPRChecker / ImageSizeTracker"], + ["Skip-when-locked re-verify period", + "30 frames", + "tryReuseLockedText default reverifyEvery=30"], + ], + col_widths=[55*mm, 50*mm, 63*mm], + mono_cols={0}, + )) + s.append(Spacer(1, 4)) + s.append(p( + "Out of the box: ALPRChecker is OFF. The pipeline emits " + "raw recognizer text per frame — no voting, no lock, no " + "skip-when-locked, no spatial dedup. Callers must opt in with " + "SetALPRCheckerEnabled(true) " + "(or ANSALPR_SetALPRCheckerEnabled(h, 1)) " + "to enable cross-frame stabilization. Once enabled, full-frame " + "auto-detect still gates it on per camera, so pre-cropped pipeline " + "calls remain stateless even when the flag is on.", + NOTE, + )) + + # ── 1.3 Public API ─────────────────────────────────────────────────── + s.append(p("1.3 Public API", H2)) + s.append(p("C++ class API (ANSCENTER::ANSALPR):")) + s.append(make_table( + ["Method", "Effect"], + [ + ["void SetALPRCheckerEnabled(bool enable)", + "Atomic flip of _enableALPRChecker. " + "Logs [ALPR_Checker] with prev/new."], + ["bool IsALPRCheckerEnabled() const", + "Atomic read. Logs the current value."], + ], + col_widths=[80*mm, 88*mm], + mono_cols={0}, + )) + s.append(Spacer(1, 4)) + s.append(p("C exports (LabVIEW / .NET / other clients):")) + s.append(make_table( + ["Function", "Args", "Return"], + [ + ["ANSALPR_SetALPRCheckerEnabled", + "Handle, int enable (0|1)", + "1 OK / -1 invalid handle / 0 exception"], + ["ANSALPR_GetALPRCheckerEnabled", + "Handle", + "1 enabled / 0 disabled / -1 invalid handle"], + ], + col_widths=[60*mm, 55*mm, 53*mm], + mono_cols={0, 1}, + )) + + # ── 1.4 State (data structures) ────────────────────────────────────── + s.append(p("1.4 Internal state (per ANSALPR instance)", H2)) + s.append(code_block([ + "class ALPRChecker {", + " int maxFrames = 60; // rolling history depth", + " int minVotesToStabilize = 3; // identical reads to lock", + " float iouMatchThreshold = 0.30f; // spatial match (legacy API)", + " std::recursive_mutex _mutex; // protects all maps", + "", + " // trackId-based primary path", + " unordered_map>", + " trackedPlatesById;", + "", + " // spatial-IoU legacy path", + " unordered_map> trackedPlates;", + "};", + "", + "struct TrackedPlateById {", + " int trackId;", + " deque textHistory; // RAW reads, capped", + " string lockedText; // \"\" until locked", + " int lockCount;", + " int framesSinceLastSeen; // for prune", + " int framesSinceVerify; // for skip-when-locked", + "};", + ])) + + # ── 1.5 Algorithm ──────────────────────────────────────────────────── + s.append(p("1.5 Core algorithm — checkPlateByTrackId", H2)) + s.append(p( + "Primary entry point. Hybrid identity strategy: trackId hash lookup " + "(O(1) common case), Levenshtein-1 fallback for lost tracks.", + )) + s.append(code_block([ + "LOCK _mutex", + "if detectedPlate empty: return \"\"", + "", + "plates = trackedPlatesById[cameraId]", + "for (id, p) in plates: p.framesSinceLastSeen++ // age all", + "", + "// Periodic prune: every 30 calls, drop entries unseen > 180 frames", + "_pruneCounterById++", + "if _pruneCounterById >= 30 and plates.size() > 20:", + " drop entries where framesSinceLastSeen > maxFrames * 3", + "", + "// PRIMARY: O(1) trackId hit", + "if trackId in plates:", + " tp = plates[trackId]", + " tp.framesSinceLastSeen = 0", + " tp.textHistory.push_back(detectedPlate) // RAW", + " if size > maxFrames: pop_front()", + "", + " voted = majorityVote(tp.textHistory)", + "", + " if tp.lockedText empty:", + " if count(history == voted) >= minVotesToStabilize: // 3", + " tp.lockedText = voted // LOCK", + " return voted", + " else:", + " if Levenshtein(detectedPlate, lockedText) == 0:", + " tp.lockCount++; return lockedText", + " elif Levenshtein(voted, lockedText) > 1:", + " // Re-lock if 3 of last 6 votes agree on new text", + " if count(recent6 == voted) >= 3:", + " tp.lockedText = voted // RE-LOCK", + " return lockedText", + " return lockedText // emit lock, ignore noise", + "", + "// FALLBACK: trackId changed (occlusion, ID switch). Migrate.", + "for (id, p) in plates:", + " if Levenshtein(detectedPlate, p.lockedText) <= 1:", + " migrate p to plates[trackId]; erase old id", + " return p.lockedText", + " elif p.lockedText empty and any of last 3 history within edit-1:", + " migrate; return majorityVote(migrated.history)", + "", + "// No match anywhere: fresh entry", + "plates[trackId] = { trackId, history=[detectedPlate], locked=\"\" }", + "return detectedPlate", + ])) + + s.append(p("1.6 majorityVote", H3)) + s.append(p( + "Recency-weighted vote with Levenshtein-1 group boosting. Newest " + "entries get weight 2.0, oldest 1.0. Variants within edit distance 1 " + "donate 0.5× their score to each candidate, so 1-character " + "OCR drift fuses instead of competing." + )) + s.append(code_block([ + "weightedFreq = {}", + "for i in 0..n-1:", + " weight = 1.0 + i / max(1, n-1) // newest=2.0, oldest=1.0", + " weightedFreq[history[i]] += weight", + "", + "for kv in weightedFreq:", + " total = kv.score", + " for other in weightedFreq:", + " if abs(len(kv) - len(other)) <= 1", + " and Levenshtein(kv, other) == 1:", + " total += other.score * 0.5", + " track best", + "return best", + ])) + + s.append(p("1.7 tryReuseLockedText — skip-when-locked fast path", H3)) + s.append(p( + "Saves ~50–95 ms per locked plate per frame by skipping " + "the OCR call entirely when a stable lock exists. Periodic re-verify " + "(every 30 frames by default) lets one OCR run through so a wrong " + "lock can self-correct via the normal voting path." + )) + s.append(code_block([ + "LOCK _mutex", + "tp = trackedPlatesById[cameraId][trackId] // miss -> return \"\"", + "if tp.lockedText empty: return \"\" // not locked yet", + "", + "if reverifyEvery > 0 and tp.framesSinceVerify >= reverifyEvery:", + " tp.framesSinceVerify = 0", + " return \"\" // signal: caller runs OCR this frame", + "", + "tp.framesSinceVerify++", + "tp.framesSinceLastSeen = 0 // critical: keep entry alive across", + " // long skip-when-locked windows", + "return tp.lockedText // skip OCR; emit lock directly", + ])) + + # ── 1.8 Pipeline integration ───────────────────────────────────────── + s.append(PageBreak()) + s.append(p("1.8 Pipeline integration", H2)) + s.append(p("shouldUseALPRChecker — full-frame vs pipeline auto-detect:")) + s.append(code_block([ + "if not _enableALPRChecker.load(relaxed): return false // master switch", + "if imageSize.width < MIN_FULLFRAME_WIDTH: return false // crop -> bypass", + "tracker = _imageSizeTrackers[cameraId]", + "if imageSize == tracker.lastSize:", + " if ++tracker.consistentCount >= CONFIRM_THRESHOLD:", + " tracker.detectedFullFrame = true", + "else:", + " tracker.lastSize = imageSize; consistentCount = 1", + " tracker.detectedFullFrame = false", + "return tracker.detectedFullFrame", + ])) + s.append(p( + "Real video gives pixel-identical frame sizes; pre-cropped calls " + "vary by a few pixels. Full-frame mode engages only after consistent " + "frames are seen, so voting kicks in once we're certain.", + NOTE, + )) + + s.append(p("1.9 OCR engine wiring (per frame)", H3)) + s.append(code_block([ + "useChecker = shouldUseALPRChecker(frameSize, cameraId) // once", + "", + "for each detected plate box:", + " if useChecker:", + " locked = tryReuseLockedText(cam, trackId)", + " if locked not empty:", + " emit { className=locked, +color }; SKIP CROP", + " continue", + " build crop(s) (padded, optionally rectified, top/bottom split)", + "", + "ONE batched recognizer call across all crops", + "", + "for each plate (non-skipped):", + " text = StripPlateArtifacts(top + \" \" + bottom)", + " if Country == JAPAN and IsJapaneseIncomplete(text):", + " text = recover kana from bottom-half tile", + " text = StripPlateSeparators(text)", + " text = AnalyseLicensePlateText(text) // <-- format filter", + " if text empty: continue // (drops invalid)", + "", + " if useChecker:", + " className = checkPlateByTrackId(cam, text, trackId)", + " else:", + " className = text // raw", + " emit { className, +color }", + "", + "if useChecker:", + " ensureUniquePlateText(output, cam) // spatial dedup", + ])) + + s.append(p("1.10 OD engine wiring", H3)) + s.append(p( + "Same gate at every alprChecker.checkPlateByTrackId " + "call. The OD path doesn't use skip-when-locked because it already " + "runs character classification per detection — nothing to skip. " + "Note OD also has a separate master " + "_enableTrackerVoting " + "flag checked before _enableALPRChecker; " + "if that one is off, the disabled-path applies regardless." + )) + + # ── 1.11 Disabled mode ────────────────────────────────────────────── + s.append(p("1.11 Disabled mode (default) vs enabled — what runs", H2)) + s.append(make_table( + ["Stage", "Enabled (opt-in)", "Disabled (default)"], + [ + ["LP detection", + "Runs", "Runs"], + ["ROI cropping + 5% padding", + "Runs", "Runs"], + ["Japan rectification + kana recovery", + "Runs (Japan only)", "Runs (Japan only)"], + ["Batched recognizer call", + "Runs", "Runs"], + ["StripPlateArtifacts / StripPlateSeparators", + "Runs", "Runs"], + ["AnalyseLicensePlateText (format filter)", + "Runs (independent toggle)", "Runs (independent toggle)"], + ["Skip-when-locked (tryReuseLockedText)", + "Runs", "Bypassed"], + ["Per-track voting (checkPlateByTrackId)", + "Runs", "Bypassed — raw recognizer text"], + ["Spatial dedup (ensureUniquePlateText)", + "Runs", "Bypassed"], + ["trackedPlatesById state", + "Populated and pruned", "Untouched (existing entries frozen)"], + ], + col_widths=[60*mm, 53*mm, 55*mm], + )) + s.append(Spacer(1, 4)) + s.append(p( + "Cost. Disabling skip-when-locked adds ~50–95 ms " + "per locked plate per frame because every plate now goes through " + "OCR every frame.", + NOTE, + )) + + # ── 1.12 Thread safety ────────────────────────────────────────────── + s.append(p("1.12 Thread safety", H2)) + s.append(make_table( + ["Concern", "Resolution"], + [ + ["Toggle race between config thread and inference thread", + "_enableALPRChecker is " + "std::atomic<bool>; " + "store/load use memory_order_relaxed. " + "Tear-free, no fence cost."], + ["Concurrent track map mutation", + "ALPRChecker::_mutex " + "(recursive) wraps every read & write of " + "trackedPlatesById / " + "trackedPlates."], + ["Concurrent spatial dedup state", + "_plateIdentitiesMutex in " + "ANSALPR_OCR protects " + "_plateIdentities."], + ["Toggle while OCR is in flight", + "Safe. The in-flight frame uses whichever value it observed; " + "the next frame picks up the new value."], + ], + col_widths=[60*mm, 108*mm], + )) + + # ── 1.13 Diagnostic logging ───────────────────────────────────────── + s.append(p("1.13 Diagnostic logging (DebugView)", H2)) + s.append(make_table( + ["Tag", "Emitted by"], + [ + ["[ALPR_Checker]", + "Set/Get accessors and C-export wrappers — every flag transition " + "and every read."], + ["[ALPR_TrackId]", + "checkPlateByTrackId — LOCKED, RE-LOCK, MIGRATED, " + "noise, NEW; tryReuseLockedText — SKIP-LOCKED, REVERIFY."], + ["[ALPR_OCR_Checker]", + "shouldUseALPRChecker — full-frame vs pipeline mode auto-detect " + "transitions per camera."], + ["[ALPR_Format]", + "AnalyseLicensePlateText — REJECT lines when a plate doesn't " + "match any configured format (see Part 2)."], + ["[OCR_Leak]", + "Once-per-60s heartbeat with sizes of each map — useful for " + "spotting unbounded growth in production."], + ], + col_widths=[40*mm, 128*mm], + mono_cols={0}, + )) + s.append(Spacer(1, 4)) + s.append(p( + "Tags are gated behind ANSCORE_DEBUGVIEW " + "and ANSCENTER_IsDebugViewEnabled(). " + "Filter DebugView on the bracketed tag to isolate any layer.", + NOTE, + )) + + # ==================================================================== + # PART 2 — Plate format + # ==================================================================== + s.append(PageBreak()) + s.append(p("Part 2 — Plate format validation", H1)) + + # ── 2.1 Purpose ────────────────────────────────────────────────────── + s.append(p("2.1 Purpose", H2)) + s.append(p( + "Reject OCR output that doesn't match any configured plate pattern. " + "Acts as a hard filter upstream of the ALPRChecker voter, so " + "malformed reads never enter textHistory " + "and a track never locks on garbage." + )) + + # ── 2.2 Pattern syntax ─────────────────────────────────────────────── + s.append(p("2.2 Pattern syntax", H2)) + s.append(p( + "Patterns are simple character templates. Each character in the " + "pattern matches one character in the candidate plate; lengths must " + "match exactly." + )) + s.append(make_table( + ["Token", "Matches", "Notes"], + [ + ["d", "Any digit (0–9)", + "std::isdigit"], + ["l", "Any letter (A–Z, a–z)", + "std::isalpha. Plate text is " + "uppercased before matching."], + ["any other char", + "Literal — must match exactly", + "Use uppercase literals (e.g. M, " + "D, NG) " + "since the plate is uppercased first."], + ], + col_widths=[20*mm, 80*mm, 68*mm], + mono_cols={0}, + )) + s.append(Spacer(1, 4)) + s.append(p( + "Empty format list = no validation; all plates accepted " + "(MatchesPlateFormat returns true). " + "Calling SetPlateFormats(emptyList) " + "disables filtering.", + NOTE, + )) + + s.append(p("2.3 Examples", H3)) + s.append(make_table( + ["Pattern", "Matches", "Doesn't match"], + [ + ["ddlddddd", + "30A12345  |  51F67890", + "30A1234 (too short)  |  30AA12345 " + "(2nd letter where digit expected)"], + ["lldddd", + "AB1234  |  QC9876", + "A12345 (1st char must be letter)  |  AB12345 " + "(too long)"], + ["dddddNGdd", + "12345NG67", + "12345NN67 (literal mismatch)"], + ["ddMDdddddd", + "12MD345678", + "12mD345678 (case mismatch on literal — plate is " + "uppercased, so 'D' must be 'D')"], + ], + col_widths=[35*mm, 65*mm, 68*mm], + mono_cols={0, 1, 2}, + )) + + # ── 2.4 Default formats per country ───────────────────────────────── + s.append(p("2.4 Default formats per country", H2)) + s.append(p( + "ApplyCountryDefaultPlateFormats() " + "populates the format list automatically based on " + "_country. Called at the end of " + "Initialize() (after country.txt is " + "read) and from SetCountry(), so a " + "runtime country switch picks up the right format set on the very " + "next frame." + )) + s.append(make_table( + ["Country", "Formats installed"], + [ + ["VIETNAM", + "ddlddddd, ddldddd, ddldddddd, ddllddddd, ddMDdddddd, " + "dddddNGdd, dddddQTdd, dddddCVdd, dddddNNdd, lldddd " + "(11 patterns covering car / motorbike / military / " + "diplomatic / police)"], + ["JAPAN, CHINA, AUSTRALIA, USA, INDONESIA, …", + "Empty — no validation. " + "AnalyseLicensePlateText is also " + "a near-no-op for non-Vietnam countries (preserves kana / " + "kanji / region-specific punctuation verbatim)."], + ], + col_widths=[55*mm, 113*mm], + )) + + # ── 2.5 Public API ────────────────────────────────────────────────── + s.append(p("2.5 Public API", H2)) + s.append(p("C++ class API (ANSCENTER::ANSALPR):")) + s.append(make_table( + ["Method", "Effect"], + [ + ["void SetPlateFormat(const string& format)", + "Replace the list with a single pattern."], + ["void SetPlateFormats(const vector<string>& formats)", + "Replace the entire list. Pass empty vector to disable validation."], + ["vector<string> GetPlateFormats() const", + "Returns the current list."], + ["virtual void SetCountry(Country c)", + "Calls ApplyCountryDefaultPlateFormats() so the list resets to " + "the country's defaults."], + ], + col_widths=[80*mm, 88*mm], + mono_cols={0}, + )) + s.append(Spacer(1, 4)) + s.append(p("C exports:")) + s.append(make_table( + ["Function", "Args", "Return"], + [ + ["ANSALPR_SetFormat", + "Handle, const char* format", + "1 OK / -1 invalid handle / 0 exception"], + ["ANSALPR_SetFormats", + "Handle, const char* formats " + "(semicolon-separated, e.g. \"ddlddddd;ddldddd;lldddd\")", + "1 OK / -1 invalid handle / 0 exception"], + ["ANSALPR_GetFormats", + "Handle, LStrHandle outFormats", + "Count written, semicolon-separated"], + ["ANSALPR_SetCountry", + "Handle, int country " + "(0=VN, 1=CN, 2=AU, 3=US, 4=ID, 5=JP)", + "1 OK / -1 invalid handle / 0 exception"], + ], + col_widths=[55*mm, 65*mm, 48*mm], + mono_cols={0, 1}, + )) + + # ── 2.6 Where it runs ─────────────────────────────────────────────── + s.append(PageBreak()) + s.append(p("2.6 Where it runs in the pipeline", H2)) + s.append(p( + "Sequential post-processing inside the per-plate loop — " + "before the ALPRChecker voter:" + )) + s.append(code_block([ + "topText, bottomText = OCR results per row", + "combinedText = StripPlateArtifacts(top + \" \" + bottom) // °, â—‹, screws", + "[Japan] kana recovery if hiragana missing", + "combinedText = StripPlateSeparators(combinedText) // -, comma, ws", + " v", + "combinedText = AnalyseLicensePlateText(combinedText) // <-- PART 2", + " 1. keep only alnum chars", + " 2. uppercase", + " 3. if _plateFormats not empty:", + " if no pattern matches: log REJECT, return \"\"", + " return cleaned plate", + " v", + "if combinedText empty: continue // dropped — voter never sees it", + " v", + "if useChecker: // <-- PART 1", + " className = checkPlateByTrackId(cam, combinedText, trackId)", + "else:", + " className = combinedText", + ])) + s.append(Spacer(1, 4)) + s.append(p( + "Consequence. When a format list is configured, the voter's " + "textHistory contains only format-valid " + "strings. lockedText is therefore " + "always format-valid by construction. A track that consistently " + "produces format-invalid OCR will never lock — it just never " + "reaches the voter, and no output is emitted for that plate.", + NOTE, + )) + + # ── 2.7 Country interaction ───────────────────────────────────────── + s.append(p("2.7 Country interaction", H2)) + s.append(p( + "AnalyseLicensePlateText behaves " + "differently per country (see " + "ANSALPR_CPU.cpp, " + "ANSALPR_OCR.cpp, " + "ANSALPR_OD.cpp):" + )) + s.append(make_table( + ["Country", "AnalyseLicensePlateText behavior"], + [ + ["VIETNAM", + "Strips non-alnum, uppercases, applies suburb-code remapping " + "(13→73, 42→62, 44→64, …), then validates " + "against _plateFormats. Mismatch → \"\""], + ["Other countries", + "Returns input unchanged so kana / kanji / region punctuation " + "flow through verbatim. _plateFormats " + "is empty by default for these countries; even if you populate " + "it manually, the format check still runs in OCR (same code " + "path) but is currently a no-op for non-Vietnam in OD."], + ], + col_widths=[35*mm, 133*mm], + )) + + # ── 2.8 Combined behavior matrix ──────────────────────────────────── + s.append(p("2.8 ALPRChecker × format combined behavior", H2)) + s.append(make_table( + ["Format set", "ALPRChecker", "Behavior"], + [ + ["empty", + "OFF", + "Raw OCR every frame. No filter, no voting. " + "Highest noise, highest recall."], + ["empty", + "ON", + "Voted/locked text. Voter learns from raw recognizer output " + "— can lock on bad reads if they're consistent."], + ["configured", + "OFF", + "Default for Vietnam. Format-filtered raw OCR per frame. " + "Invalid reads dropped, valid ones emitted as-is " + "(no cross-frame memory)."], + ["configured", + "ON", + "Recommended for stable cameras. Format filters bad " + "reads out, voter locks the surviving canonical text. Best " + "stability, lowest false-positive rate. Opt in with " + "SetALPRCheckerEnabled(true)."], + ], + col_widths=[35*mm, 30*mm, 103*mm], + mono_cols={0, 1}, + )) + s.append(Spacer(1, 4)) + s.append(p( + "Toggling at runtime. Both flags are independent and " + "thread-safe. Existing locks survive a format-set change — " + "they're not retroactively re-validated. To force a clean slate, " + "destroy and recreate the ANSALPR handle (or wait for the prune " + "pass to expire stale tracks).", + NOTE, + )) + + # ── 2.9 Caller recipes ────────────────────────────────────────────── + s.append(p("2.9 Caller recipes", H2)) + s.append(make_table( + ["Goal", "C export sequence"], + [ + ["Default pipeline (raw OCR + format filter, no voting)", + "Nothing — defaults are fine."], + ["Enable tracker voting + skip-when-locked", + "ANSALPR_SetALPRCheckerEnabled(h, 1)"], + ["Switch country at runtime", + "ANSALPR_SetCountry(h, 5)   // Japan; resets formats"], + ["Vietnam-only police plates", + "ANSALPR_SetFormats(h, \"dddddCVdd\")"], + ["Vietnam plus a custom long-form pattern", + "ANSALPR_SetFormats(h, \"ddlddddd;ddldddd;dddddCVdd;ddldddddddd\")"], + ["Disable format validation entirely", + "ANSALPR_SetFormats(h, \"\")   // empty -> accept all"], + ["Disable tracker voting (revert to raw OCR every frame)", + "ANSALPR_SetALPRCheckerEnabled(h, 0)"], + ["Read current state", + "ANSALPR_GetALPRCheckerEnabled(h); ANSALPR_GetFormats(h, &buf)"], + ], + col_widths=[68*mm, 100*mm], + mono_cols={1}, + )) + + # ── 2.10 Diagnostic logging ───────────────────────────────────────── + s.append(p("2.10 Diagnostic logging (DebugView)", H2)) + s.append(code_block([ + "[ANSLPR] ANSALPR_SetFormat: HandlePtr=0x... format=ddlddddd", + "[ANSLPR] ANSALPR_SetFormats: HandlePtr=0x... formats=ddlddddd;lldddd", + "[ANSLPR] ANSALPR_SetCountry: HandlePtr=0x... country=0", + "[ALPR_Format] REJECT plate='30AA1234' (no _plateFormats match)", + ])) + s.append(p( + "Filter on [ALPR_Format] to count how " + "many plates the format filter is rejecting per camera per minute. " + "A high reject rate with a low ALPR result count means the format " + "list is too tight for what the recognizer is producing.", + NOTE, + )) + + # ── Footer ────────────────────────────────────────────────────────── + s.append(Spacer(1, 14)) + s.append(p( + "This guide reflects the ANSLPR API as of the ALPRChecker atomic " + "+ getter export change. File references point to " + "modules/ANSLPR/ANSLPR.{h,cpp}, modules/ANSLPR/ANSLPR_OCR.{h,cpp}, " + "modules/ANSLPR/ANSLPR_OD.{h,cpp}, modules/ANSLPR/ANSLPR_CPU.cpp, " + "and modules/ANSLPR/dllmain.cpp.", + NOTE, + )) + + return s + + +# --------------------------------------------------------------------------- # +# Build # +# --------------------------------------------------------------------------- # +def main(): + doc = SimpleDocTemplate( + str(OUTPUT), + pagesize=A4, + leftMargin=18*mm, rightMargin=18*mm, + topMargin=18*mm, bottomMargin=18*mm, + title="ANSLPR — ALPRChecker & Plate Format Developer Guide", + author="ANSCORE", + ) + story = build_story() + doc.build(story) + print(f"Wrote {OUTPUT}") + + +if __name__ == "__main__": + main() diff --git a/modules/ANSLPR/ANSLPR.h b/modules/ANSLPR/ANSLPR.h index 43fed0e..31c69bb 100644 --- a/modules/ANSLPR/ANSLPR.h +++ b/modules/ANSLPR/ANSLPR.h @@ -145,7 +145,16 @@ namespace ANSCENTER // ALPRChecker toggle (Layer 2 + Layer 3): // true = enabled for full-frame, auto-disabled for pipeline/crop // false = force disabled everywhere (raw OCR pass-through) - bool _enableALPRChecker{ true }; + // Default OFF — callers must opt in with SetALPRCheckerEnabled(true) + // to get tracker voting / skip-when-locked / spatial dedup. Keeps + // the out-of-the-box pipeline stateless so first-frame results match + // per-frame results exactly, and avoids surprises for callers that + // drive the engine with pre-cropped pipeline inputs. + // Atomic so the inference threads can read it without a lock while + // config threads (LabVIEW/UI/REST) flip it at runtime. Relaxed + // ordering is sufficient: we only need the read to be tear-free, and + // "next frame picks up the new value" is the intended contract. + std::atomic _enableALPRChecker{ false }; public: [[nodiscard]] virtual bool Initialize(const std::string& licenseKey, const std::string& modelZipFilePath, const std::string& modelZipPassword, double detectorThreshold, double ocrThreshold, double colourTheshold=0); @@ -193,8 +202,20 @@ namespace ANSCENTER /// Enable/disable ALPRChecker (Layer 2 text stabilization + Layer 3 dedup): /// true = enabled for full-frame, auto-disabled for pipeline/crop /// false = force disabled everywhere (raw OCR pass-through) - void SetALPRCheckerEnabled(bool enable) { _enableALPRChecker = enable; } - bool IsALPRCheckerEnabled() const { return _enableALPRChecker; } + void SetALPRCheckerEnabled(bool enable) { + const bool prev = _enableALPRChecker.exchange(enable, std::memory_order_relaxed); + ANS_DBG("ALPR_Checker", + "SetALPRCheckerEnabled this=%p prev=%d new=%d (%s)", + (void*)this, prev ? 1 : 0, enable ? 1 : 0, + enable ? "ON" : "OFF"); + } + bool IsALPRCheckerEnabled() const { + const bool value = _enableALPRChecker.load(std::memory_order_relaxed); + ANS_DBG("ALPR_Checker", + "IsALPRCheckerEnabled this=%p value=%d (%s)", + (void*)this, value ? 1 : 0, value ? "ON" : "OFF"); + return value; + } virtual void SetCountry(Country country) { _country = country; } Country GetCountry() const { return _country; } @@ -262,6 +283,8 @@ extern "C" ANSLPR_API int ANSALPR_GetFormats(ANSCENTER::ANSALPR** Handle, LS // ALPRChecker: 1 = enabled (full-frame auto-detected), 0 = disabled (raw OCR) extern "C" ANSLPR_API int ANSALPR_SetALPRCheckerEnabled(ANSCENTER::ANSALPR** Handle, int enable); +// Returns the current ALPRChecker flag: 1 = enabled, 0 = disabled, -1 = invalid handle. +extern "C" ANSLPR_API int ANSALPR_GetALPRCheckerEnabled(ANSCENTER::ANSALPR** Handle); // Country: 0=VIETNAM, 1=CHINA, 2=AUSTRALIA, 3=USA, 4=INDONESIA, 5=JAPAN extern "C" ANSLPR_API int ANSALPR_SetCountry(ANSCENTER::ANSALPR** Handle, int country); diff --git a/modules/ANSLPR/ANSLPR_OCR.cpp b/modules/ANSLPR/ANSLPR_OCR.cpp index 29c66d4..c41bed6 100644 --- a/modules/ANSLPR/ANSLPR_OCR.cpp +++ b/modules/ANSLPR/ANSLPR_OCR.cpp @@ -1231,8 +1231,10 @@ namespace ANSCENTER // ALPRChecker voting + ensureUniquePlateText dedup. bool ANSALPR_OCR::shouldUseALPRChecker(const cv::Size& imageSize, const std::string& cameraId) { - // Force disabled via SetALPRCheckerEnabled(false) → never use. - if (!_enableALPRChecker) return false; + // Force disabled via SetALPRCheckerEnabled(false) → never use. Relaxed + // atomic load: tear-free read is all we need, "next frame sees the new + // value" is the intended contract. + if (!_enableALPRChecker.load(std::memory_order_relaxed)) return false; // Small images are always pipeline crops — skip auto-detection. if (imageSize.width < ImageSizeTracker::MIN_FULLFRAME_WIDTH) return false; diff --git a/modules/ANSLPR/ANSLPR_OD.cpp b/modules/ANSLPR/ANSLPR_OD.cpp index 38a843a..8487d64 100644 --- a/modules/ANSLPR/ANSLPR_OD.cpp +++ b/modules/ANSLPR/ANSLPR_OD.cpp @@ -1041,8 +1041,9 @@ namespace ANSCENTER { // voting and ensureUniquePlateText dedup in all Inference/RunInference paths. if (!_enableTrackerVoting) return false; - // Force disabled → never use - if (!_enableALPRChecker) return false; + // Force disabled → never use. Relaxed load is fine: tear-free read of a + // single bool is all we need; "next frame sees the new value" is the contract. + if (!_enableALPRChecker.load(std::memory_order_relaxed)) return false; // Small images are always pipeline crops — skip auto-detection if (imageSize.width < ImageSizeTracker::MIN_FULLFRAME_WIDTH) return false; diff --git a/modules/ANSLPR/dllmain.cpp b/modules/ANSLPR/dllmain.cpp index 6b8f712..e7fad94 100644 --- a/modules/ANSLPR/dllmain.cpp +++ b/modules/ANSLPR/dllmain.cpp @@ -965,7 +965,11 @@ extern "C" ANSLPR_API int ANSALPR_SetFormats(ANSCENTER::ANSALPR** Handle, co extern "C" ANSLPR_API int ANSALPR_SetALPRCheckerEnabled(ANSCENTER::ANSALPR** Handle, int enable) { ANS_DBG("ANSLPR","ANSALPR_SetALPRCheckerEnabled: HandlePtr=%p, *Handle=%p, enable=%d", (void*)Handle, (void*)(Handle ? *Handle : nullptr), enable); - if (!Handle || !*Handle) return -1; + if (!Handle || !*Handle) { + ANS_DBG("ALPR_Checker", + "ANSALPR_SetALPRCheckerEnabled: invalid handle, returning -1"); + return -1; + } try { (*Handle)->SetALPRCheckerEnabled(enable != 0); ANS_DBG("ALPR_Checker", "SetALPRCheckerEnabled=%d (%s)", @@ -973,10 +977,34 @@ extern "C" ANSLPR_API int ANSALPR_SetALPRCheckerEnabled(ANSCENTER::ANSALPR** return 1; } catch (...) { + ANS_DBG("ALPR_Checker", + "ANSALPR_SetALPRCheckerEnabled: exception caught, returning 0"); return 0; } } +// Returns the current ALPRChecker flag: 1 = enabled, 0 = disabled, -1 = invalid handle. +extern "C" ANSLPR_API int ANSALPR_GetALPRCheckerEnabled(ANSCENTER::ANSALPR** Handle) { + ANS_DBG("ANSLPR","ANSALPR_GetALPRCheckerEnabled: HandlePtr=%p, *Handle=%p", + (void*)Handle, (void*)(Handle ? *Handle : nullptr)); + if (!Handle || !*Handle) { + ANS_DBG("ALPR_Checker", + "ANSALPR_GetALPRCheckerEnabled: invalid handle, returning -1"); + return -1; + } + try { + const bool enabled = (*Handle)->IsALPRCheckerEnabled(); + ANS_DBG("ALPR_Checker", "GetALPRCheckerEnabled=%d (%s)", + enabled ? 1 : 0, enabled ? "ON" : "OFF"); + return enabled ? 1 : 0; + } + catch (...) { + ANS_DBG("ALPR_Checker", + "ANSALPR_GetALPRCheckerEnabled: exception caught, returning -1"); + return -1; + } +} + extern "C" ANSLPR_API int ANSALPR_SetCountry(ANSCENTER::ANSALPR** Handle, int country) { ANS_DBG("ANSLPR","ANSALPR_SetCountry: HandlePtr=%p, *Handle=%p, country=%d", (void*)Handle, (void*)(Handle ? *Handle : nullptr), country); diff --git a/tests/ANSLPR-UnitTest/ANSLPR-UnitTest.cpp b/tests/ANSLPR-UnitTest/ANSLPR-UnitTest.cpp index d57eba7..dd20c53 100644 --- a/tests/ANSLPR-UnitTest/ANSLPR-UnitTest.cpp +++ b/tests/ANSLPR-UnitTest/ANSLPR-UnitTest.cpp @@ -116,8 +116,9 @@ int ANSLPR_CPU_VideoTest() { boost::property_tree::ptree detectionObjects; boost::property_tree::ptree pt; ANSCENTER::ANSALPR* infHandle = new ANSCENTER::ANSALPR_CPU(); + infHandle->SetALPRCheckerEnabled(true); std::string licenseKey = ""; - std::string modelZipFile = currentPath.string() + "\\ANS_GenericALPR_v1.0.zip"; + std::string modelZipFile = currentPath.string() + "\\ANS_GenericALPR_v1.0.zip"; modelZipFile = "C:\\ProgramData\\ANSCENTER\\Shared\\ANS_GenericALPR_v1.0.zip"; std::string videoFilePath = "C:\\Programs\\DemoAssets\\Videos\\ALRP\\ALPR1.mp4"; std::string lpnResult; @@ -186,6 +187,7 @@ int ANSLPR_BigSize_VideoTest() { boost::property_tree::ptree detectionObjects; boost::property_tree::ptree pt; ANSCENTER::ANSALPR* infHandle = new ANSCENTER::ANSALPR_CPU(); + infHandle->SetALPRCheckerEnabled(true); std::string licenseKey = ""; std::string modelZipFile = currentPath.string() + "\\ANS_GenericALPR_v1.0.zip"; modelZipFile = "C:\\ProgramData\\ANSCENTER\\Shared\\ANS_GenericALPR_v1.0.zip"; @@ -284,7 +286,8 @@ int ANSLPR_CPU_Inferences_FileTest() { std::string StrBox = readJsonFile("C:\\Projects\\ANLS\\Documents\\bboxStr.json"); int result = CreateANSALPRHandle(& infHandle, "", modelZipFile.c_str(), "",0,0.5,0.5,0); - std::cout << "Init Result:" << result << std::endl; + std::cout << "Init Result:" << result << std::endl; + ANSALPR_SetALPRCheckerEnabled(&infHandle, 1); unsigned int bufferLength = 0; cv::Mat input = cv::imread(imageFilePath, cv::IMREAD_COLOR); @@ -341,6 +344,7 @@ int ANSLPR_CV_VideoTest() { std::string lpnResult; int result = CreateANSALPRHandle(& infHandle, licenseKey.c_str(), modelZipFile.c_str(), "",0,0.5,0.5,0); std::cout << "Loading ANSLRP:" << result << std::endl; + ANSALPR_SetALPRCheckerEnabled(&infHandle, 1); cv::VideoCapture capture(videoFilePath); if (!capture.isOpened()) { printf("could not read this video file...\n"); @@ -421,7 +425,8 @@ int ANSLPR_OD_VideoTest() { double detectionColourThreshold = 0.5; int result = CreateANSALPRHandle(&infHandle, licenseKey.c_str(), modelZipFile.c_str(), "", engineType, detectionThreshold, ocrThreshold, detectionColourThreshold); std::cout << "Loading ANSLRP:" << result << std::endl; - + ANSALPR_SetALPRCheckerEnabled(&infHandle, 1); + int loadEngine = LoadANSALPREngineHandle(&infHandle); std::cout << "Loading ANSLRP:" << loadEngine << std::endl; cv::VideoCapture capture(videoFilePath); @@ -506,6 +511,7 @@ int ANSLPR_OD_Inferences_FileTest() { double colourThreshold = 0.5; int result = CreateANSALPRHandle(&infHandle, licenseKey.c_str(), modelZipFile.c_str(), "", engineType, detectionThreshold, ocrThreshold, colourThreshold); std::cout << "Loading ANSLRP:" << result << std::endl; + ANSALPR_SetALPRCheckerEnabled(&infHandle, 1); auto start = std::chrono::system_clock::now(); @@ -581,6 +587,7 @@ int ANSLPR_OD_FolderInferences_Test() { int result = CreateANSALPRHandle(&infHandle, licenseKey.c_str(), modelZipFile.c_str(), "", engineType, detectionThreshold, ocrThreshold, colourThreshold); std::cout << "Loading ANSLPR: " << result << std::endl; + ANSALPR_SetALPRCheckerEnabled(&infHandle, 1); auto startLoad = std::chrono::system_clock::now(); int loadEngine = LoadANSALPREngineHandle(&infHandle); @@ -702,6 +709,7 @@ int ANSLPR_OD_INDOInferences_FileTest() { double ocrThreshold = 0.5; int result = CreateANSALPRHandle(&infHandle, licenseKey.c_str(), modelZipFile.c_str(), "", engineType, detectionThreshold, ocrThreshold, 0.5); std::cout << "Loading ANSLRP:" << result << std::endl; + ANSALPR_SetALPRCheckerEnabled(&infHandle, 1); int loadEngine = LoadANSALPREngineHandle(&infHandle); std::cout << "Init Result:" << result << std::endl; @@ -1210,6 +1218,7 @@ int ANSLPR_SingleTask_Test() { ANSCENTER::ANSOPENCV::DeinitCameraNetwork(); return -1; } + ANSALPR_SetALPRCheckerEnabled(&alprHandle, 1); printf("[Task0] Loading ALPR engine...\n"); int loadResult = LoadANSALPREngineHandle(&alprHandle); @@ -1388,6 +1397,7 @@ int ANSLPR_CPU_StressTest() { g_log.add(std::string(tag) + " ALPR create FAILED"); continue; } + ANSALPR_SetALPRCheckerEnabled(&alprHandles[i], 1); printf("%s Loading ALPR engine...\n", tag); int loadResult = LoadANSALPREngineHandle(&alprHandles[i]); @@ -1713,6 +1723,7 @@ int ANSLPR_MultiGPU_StressTest() { taskStates[i].statusMsg = "ALPR create failed"; continue; } + ANSALPR_SetALPRCheckerEnabled(&alprHandles[i], 1); printf("%s Loading ALPR engine (%s)...\n", tag, hasGpu ? "TensorRT" : "CPU"); g_log.add(std::string(tag) + " Loading ALPR engine..."); @@ -2602,6 +2613,7 @@ int ANSLPR_MultiGPU_StressTest_SimulatedCam() { taskStates[i].statusMsg = "ALPR create failed"; continue; } + ANSALPR_SetALPRCheckerEnabled(&alprHandles[i], 1); printf("%s Loading ALPR engine (TensorRT)...\n", tag); g_log.add(std::string(tag) + " Loading ALPR engine..."); @@ -3231,6 +3243,7 @@ int ANSLPR_MultiGPU_StressTest_FilePlayer() { taskStates[i].statusMsg = "ALPR create failed"; continue; } + ANSALPR_SetALPRCheckerEnabled(&alprHandles[i], 1); printf("%s Loading ALPR engine (TensorRT)...\n", tag); g_log.add(std::string(tag) + " Loading ALPR engine..."); @@ -3610,6 +3623,7 @@ int ANSLPR_OD_CPU_VideoTest() { std::cerr << "[LPR-CPU] FAILED: CreateANSALPRHandle returned " << createResult << std::endl; return -1; } + ANSALPR_SetALPRCheckerEnabled(&infHandle, 1); // Step 2: Load engine std::cout << "[LPR-CPU] Step 2: Loading engine..." << std::endl; @@ -3796,6 +3810,7 @@ int ALPR_OCR_Test() { std::cerr << "Failed to create ANSALPR_OCR handle" << std::endl; return -1; } + ANSALPR_SetALPRCheckerEnabled(&infHandle, 1); // Step 2: Set country to Japan ANSALPR_SetCountry(&infHandle, 5); // JAPAN = 5 @@ -3953,6 +3968,7 @@ int ALPR_OCR_VideoTest() { std::cerr << "Failed to create ANSALPR_OCR handle" << std::endl; return -1; } + ANSALPR_SetALPRCheckerEnabled(&infHandle, 1); // Step 2: Set country (VIETNAM = 0 — adjust to match the dataset if needed). // Country codes match country.txt parsing in ANSALPR_OCR::Initialize: @@ -4780,6 +4796,7 @@ int ALPR_Helmet_Parallel_VideoTest() { ANSCENTER::ANSOPENCV::DeinitCameraNetwork(); return -2; } + ANSALPR_SetALPRCheckerEnabled(&alprHandle, 1); ANSALPR_SetCountry(&alprHandle, alprCountry); auto loadStart = std::chrono::steady_clock::now(); int loadResult = LoadANSALPREngineHandle(&alprHandle); @@ -5056,6 +5073,7 @@ int ALPR_OCR_FolderInferences_Test() { std::cerr << "Failed to create ANSALPR_OCR handle" << std::endl; return -1; } + ANSALPR_SetALPRCheckerEnabled(&infHandle, 1); // Step 2: Country = VIETNAM (0). Activates Vietnam-only post-processing // (alnum filter + uppercase + format validation against the 11 standard