int testAmmCaptcha()
{
AmmCaptcha_initialize("font.ppm","ourDictionaryCaptcha.txt");
struct Image * captcha = createImage(300,70,3);
RenderString(captcha,&fontRAW, 0 , 20, "AmmarServer FTW");
WritePPM(captcha,"captcha.ppm");
coolPHPWave(captcha, 11,12,5,14);
WriteJPEGFile(captcha,"captcha.jpg");
/*
RenderString(captcha,&fontRAW, 0 , 30, "abcdefghijklmnopqrstuvwxyz");
RenderString(captcha,&fontRAW, 0 , 50, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
RenderString(captcha,&fontRAW, 0 , 70, "0123456789");
RenderString(captcha,&fontRAW, 0 , 90, "ABCDTest123");
RenderString(captcha,&fontRAW, 0 , 120, "012345Test123");*/
//warpImage(captcha, 40, 120 , 60 , 150);
AmmCaptcha_destroy();
return 0;
}
void ScatterBiasArea(int roi, float scan_width, int steps, int samples, int qi_it, float angstep)
{
std::vector<float> u=linspace(roi/2-scan_width/2,roi/2+scan_width/2, steps);
QTrkComputedConfig cfg;
cfg.width=cfg.height=roi;
cfg.qi_angstep_factor = angstep;
cfg.qi_iterations = qi_it;
cfg.qi_angular_coverage = 0.7f;
cfg.qi_roi_coverage = 1;
cfg.qi_radial_coverage = 1.5f;
cfg.qi_minradius=0;
cfg.zlut_minradius=0;
cfg.zlut_angular_coverage = 0.7f;
cfg.zlut_roi_coverage = 1;
cfg.zlut_radial_coverage = 1.5f;
cfg.zlut_minradius = 0;
cfg.qi_minradius = 0;
cfg.com_bgcorrection = 0;
cfg.xc1_profileLength = roi*0.8f;
cfg.xc1_profileWidth = roi*0.2f;
cfg.xc1_iterations = 1;
cfg.Update();
ImageData lut,orglut = ReadLUTFile("10x.radialzlut#4");
vector3f ct(roi/2,roi/2,lut.h/2 + 0.123f);
float dx = scan_width/steps;
QueuedCPUTracker trk(cfg);
ResampleLUT(&trk, &orglut, orglut.h, &lut);
int maxval = 10000;
ImageData tmp=ImageData::alloc(roi,roi);
GenerateImageFromLUT(&tmp, &lut, 0, cfg.zlut_maxradius, vector3f(roi/2,roi/2,lut.h/2));
ApplyPoissonNoise(tmp, maxval);
std::string fn = SPrintf( "sb_area_roi%d_scan%d_steps%d_qit%d_N%d", roi, (int)scan_width, steps, qi_it, samples);
WriteJPEGFile( (fn + ".jpg").c_str(), tmp);
tmp.free();
fn += ".txt";
for (int y=0;y<steps;y++) {
for (int x=0;x<steps;x++)
{
vector3f cpos( (x+0.5f-steps/2) * dx, (y+0.5f-steps/2) * dx, 0 );
cfg.qi_iterations = qi_it;
auto r= AccBiasTest(orglut, &trk, samples, cpos+ct, vector3f(), 0, maxval, qi_it < 0 ? LT_XCor1D : 0);
float row[] = { r.acc.x, r.acc.y, r.acc.z, r.bias.x, r.bias.y, r.bias.z, r.crlb.x, r.crlb.z, samples };
WriteArrayAsCSVRow(fn.c_str(), row, 9, x+y>0);
dbgprintf("X=%d,Y=%d\n", x,y);
}
}
orglut.free();
lut.free();
}
int jpegtest()
{
char *infilename = (char*) "test.jpg", *outfilename = (char*) "test_out.jpg";
/* Try opening a jpeg*/
if( ReadJPEG( infilename , 0 , 0 ) > 0 )
{
/* then copy it to another file */
if( WriteJPEGFile( 0 , outfilename ) < 0 ) return -1;
}
else return -1;
return 0;
}
// save Jpeg file
BOOL CJpeg::Save(LPCSTR lpstrFileName, CDib* pDib, BOOL bColor, int nQuality)
{
if (pDib == NULL)
pDib = m_pDib;
if (pDib == NULL)
return FALSE;
HDIB hDib = CopyHandle(pDib->GetHandle());
if (hDib == NULL)
return FALSE;
CDib* pDibTmp = new CDib;
pDibTmp->Attach(hDib);
if (pDibTmp->GetBitCount() != 24)
pDibTmp->ConvertFormat(24);
UINT uWidth = pDibTmp->GetWidth();
UINT uHeight = pDibTmp->GetHeight();
// convert from DIB format (DWORD aligned, vertically flipped, red and blue swapped)
BYTE* tmp = ClearDwordAlign(pDibTmp->GetBitsPtr(),
uWidth,
WIDTHBYTES(uWidth * 24),
uHeight);
if (tmp == NULL)
return FALSE;
// convert from DIB
VertFlipBuf(tmp, uWidth*3, uHeight);
BGRFromRGB(tmp, uWidth, uHeight);
BOOL bSuccess = WriteJPEGFile(lpstrFileName,
tmp,
uWidth,
uHeight,
bColor,
nQuality);
delete pDibTmp;
FreeBuffer(tmp);
return bSuccess;
}
void TestBias()
{
ImageData lut = ReadLUTFile("lut000.jpg");
ImageData img = ImageData::alloc(80,80);
CPUTracker trk(img.w,img.h);
float o = 2.03f;
vector3f pos (img.w/2+o, img.h/2+o, lut.h/2);
NormalizeZLUT(lut.data, 1, lut.h, lut.w);
lut.normalize();
srand(time(0));
for (int i=0;i<10;i++) {
GenerateImageFromLUT(&img, &lut, 0, img.w/2, pos, true);
ApplyPoissonNoise(img, 11050);
float stdev = StdDeviation(img.data, img.data + img.w);
dbgprintf("Noise level std: %f\n",stdev);
}
WriteJPEGFile("TestBias-smp.jpg", img);
trk.SetImageFloat(img.data);
vector2f com = trk.ComputeMeanAndCOM();
dbgprintf("COM: x:%f, y:%f\n", com.x,com.y);
bool bhit;
auto rw = ComputeRadialBinWindow(img.w);
vector2f qi = trk.ComputeQI(com, 3, img.w, 3*img.w/4, 1, 0, img.w/2, bhit, &rw[0]);
dbgprintf("QI: x: %f, y:%f\n", qi.x,qi.y);
trk.SetRadialZLUT(lut.data, lut.h, lut.w, 1, 0, img.w/2, true, false);
float z = trk.ComputeZ(qi,3*img.w, 0, 0, 0, 0, false);
float znorm = trk.ComputeZ(qi,3*img.w, 0, 0, 0, 0, true);
dbgprintf("Z: %f, ZNorm: %f, true:%f\n", z, znorm, pos.z);
img.free();
lut.free();
}
void GenerateZLUTFittingCurve(const char *lutfile)
{
QTrkSettings settings;
settings.width = settings.height = 80;
QueuedCPUTracker qt(settings);
ImageData lut = ReadJPEGFile(lutfile);
ImageData nlut;
ResampleLUT(&qt, &lut, lut.h, &nlut);
CPUTracker trk(settings.width,settings.height);
ImageData smp = ImageData::alloc(settings.width,settings.height);
trk.SetRadialZLUT(nlut.data, nlut.h, nlut.w, 1, qt.cfg.zlut_minradius, qt.cfg.zlut_maxradius, false, false);
int N=8;
for (int z=0;z<6;z++) {
vector3f pos(settings.width/2,settings.height/2, nlut.h * (1+z) / (float)N + 0.123f);
GenerateImageFromLUT(&smp, &nlut, qt.cfg.zlut_minradius, qt.cfg.zlut_maxradius, pos);
ApplyPoissonNoise(smp, 10000);
WriteJPEGFile( SPrintf("zlutfitcurve-smpimg-z%d.jpg", z).c_str(), smp);
trk.SetImageFloat(smp.data);
std::vector<float> profile(qt.cfg.zlut_radialsteps), cmpProf(nlut.h), fitted(nlut.h);
trk.ComputeRadialProfile(&profile[0], qt.cfg.zlut_radialsteps, qt.cfg.zlut_angularsteps, qt.cfg.zlut_minradius, qt.cfg.zlut_maxradius, pos.xy(), false);
trk.LUTProfileCompare(&profile[0], 0, &cmpProf[0], CPUTracker::LUTProfMaxQuadraticFit, &fitted[0]);
WriteArrayAsCSVRow("zlutfitcurve-profile.txt", &profile[0], profile.size(), z>0);
WriteArrayAsCSVRow("zlutfitcurve-cmpprof.txt", &cmpProf[0], cmpProf.size(), z>0);
WriteArrayAsCSVRow("zlutfitcurve-fitted.txt", &fitted[0], fitted.size(), z>0);
}
smp.free();
nlut.free();
lut.free();
}
void TestZRangeBias(const char *name, const char *lutfile, bool normProf)
{
ImageData lut = ReadLUTFile(lutfile);
QTrkComputedConfig settings;
settings.width=settings.height=100;
settings.Update();
ImageData img=ImageData::alloc(settings.width,settings.height);
CPUTracker trk(settings.width,settings.height);
NormalizeZLUT(lut.data, 1, lut.h, lut.w);
trk.SetRadialZLUT(lut.data, lut.h, lut.w, 1, 1, settings.qi_maxradius, true, false);
float* prof= ALLOCA_ARRAY(float,lut.w);
int N=1000;
std::vector< vector2f> results (N);
for (int i=0;i<N;i++) {
vector3f pos (settings.width/2, settings.height/2, i/(float)N*lut.h);
GenerateImageFromLUT(&img, &lut, 1, settings.qi_maxradius, pos);
if(InDebugMode&&i==0){
WriteJPEGFile(SPrintf("%s-smp.jpg",name).c_str(),img);
}
trk.SetImageFloat(img.data);
//trk.ComputeRadialProfile(prof,lut.w,settings.zlut_angularsteps, settings.zlut_minradius, settings.zlut_maxradius, pos.xy(), false);
//float z=trk.LUTProfileCompare(prof, 0, 0, normProf ? CPUTracker::LUTProfMaxSplineFit : CPUTracker::LUTProfMaxQuadraticFit); result: splines no go!
float z = trk.ComputeZ(pos.xy(), settings.zlut_angularsteps, 0, 0, 0, 0,true);
results[i].x = pos.z;
results[i].y = z-pos.z;
}
WriteImageAsCSV(SPrintf("%s-results.txt", name).c_str(),(float*) &results[0], 2, N);
lut.free();
img.free();
}
void TestZRange(const char *name, const char *lutfile, int extraFlags, int clean_lut, RWeightMode weightMode=RWNone, bool biasMap=false, bool biasCorrect=false)
{
ImageData lut = ReadLUTFile(lutfile);
vector3f delta(0.001f,0.001f, 0.001f);
if(PathSeperator(lutfile).extension != "jpg"){
WriteJPEGFile(SPrintf("%s-lut.jpg",name).c_str(), lut);
}
if (clean_lut) {
BenchmarkLUT::CleanupLUT(lut);
WriteJPEGFile( std::string(lutfile).substr(0, strlen(lutfile)-4).append("_bmlut.jpg").c_str(), lut );
}
QTrkComputedConfig settings;
settings.qi_iterations = 2;
settings.zlut_minradius = 1;
settings.qi_minradius = 1;
settings.width = settings.height = 100;
settings.Update();
float maxVal=10000;
std::vector<float> stdv;
dbgprintf("High-res LUT range...\n");
SampleFisherMatrix fm( maxVal);
QueuedCPUTracker trk(settings);
ImageData rescaledLUT;
ResampleLUT(&trk, &lut, lut.h, &rescaledLUT);
if (biasCorrect) {
CImageData result;
trk.ComputeZBiasCorrection(lut.h*10, &result, 4, true);
WriteImageAsCSV(SPrintf("%s-biasc.txt", name).c_str(), result.data, result.w, result.h);
}
int f = 0;
if (weightMode == RWDerivative)
f |= LT_LocalizeZWeighted;
else if(weightMode == RWRadial) {
std::vector<float> w(settings.zlut_radialsteps);
for (int i=0;i<settings.zlut_radialsteps;i++)
w[i]= settings.zlut_minradius + i/(float)settings.zlut_radialsteps*settings.zlut_maxradius;
trk.SetRadialWeights(&w[0]);
}
else if (weightMode == RWStetson)
trk.SetRadialWeights( ComputeRadialBinWindow(settings.zlut_radialsteps) );
trk.SetLocalizationMode(LT_QI|LT_LocalizeZ|LT_NormalizeProfile|extraFlags|f);
uint nstep= InDebugMode ? 20 : 1000;
uint smpPerStep = InDebugMode ? 2 : 200;
if (biasMap) {
smpPerStep=1;
nstep=InDebugMode? 200 : 2000;
}
std::vector<vector3f> truepos, positions,crlb;
std::vector<float> stdevz;
for (uint i=0;i<nstep;i++)
{
float z = 1 + i / (float)nstep * (rescaledLUT.h-2);
vector3f pos = vector3f(settings.width/2, settings.height/2, z);
truepos.push_back(pos);
Matrix3X3 invFisherLUT = fm.Compute(pos, delta, rescaledLUT, settings.width, settings.height, settings.zlut_minradius, settings.zlut_maxradius).Inverse();
crlb.push_back(sqrt(invFisherLUT.diag()));
ImageData img=ImageData::alloc(settings.width,settings.height);
for (uint j=0;j<smpPerStep; j++) {
vector3f rndvec(rand_uniform<float>(), rand_uniform<float>(), rand_uniform<float>());
if (biasMap) rndvec=vector3f();
vector3f rndpos = pos + vector3f(1,1,0.1) * (rndvec-0.5f); // 0.1 plane is still a lot larger than the 0.02 typical accuracy
GenerateImageFromLUT(&img, &rescaledLUT, settings.zlut_minradius, settings.zlut_maxradius, rndpos, true);
img.normalize();
if (!biasMap) ApplyPoissonNoise(img, maxVal);
LocalizationJob job(positions.size(), 0, 0, 0);
trk.ScheduleImageData(&img, &job);
positions.push_back(rndpos);
if(j==0 && InDebugMode) {
WriteJPEGFile(SPrintf("%s-sampleimg.jpg",name).c_str(), img);
}
}
dbgprintf("[%d] z=%f Min std deviation: X=%f, Y=%f, Z=%f.\n", i, z, crlb[i].x,crlb[i].y,crlb[i].z);
img.free();
}
WaitForFinish(&trk, positions.size());
std::vector<vector3f> trkmean(nstep), trkstd(nstep);
std::vector<vector3f> resultpos(nstep*smpPerStep);
for (uint i=0;i<positions.size();i++) {
LocalizationResult lr;
trk.FetchResults(&lr, 1);
resultpos[lr.job.frame]=lr.pos;
}
for (uint i=0;i<nstep;i++) {
for (uint j=0;j<smpPerStep;j ++) {
vector3f err=resultpos[i*smpPerStep+j]-positions[i*smpPerStep+j];
trkmean[i]+=err;
}
trkmean[i]/=smpPerStep;
vector3f variance;
for (uint j=0;j<smpPerStep;j ++) {
vector3f r = resultpos[i*smpPerStep+j];
vector3f t = positions[i*smpPerStep+j];;
vector3f err=r-t;
err -= trkmean[i];
variance += err*err;
if (InDebugMode) {
dbgprintf("Result: x=%f,y=%f,z=%f. True: x=%f,y=%f,z=%f\n", r.x,r.y,r.z,t.x,t.y,t.z);
}
}
if (biasMap) trkstd[i]=vector3f();
else trkstd[i] = sqrt(variance / (smpPerStep-1));
}
vector3f mean_std;
std::vector<float> output;
for(uint i=0;i<nstep;i++) {
dbgprintf("trkstd[%d]:%f crlb=%f bias=%f true=%f\n", i, trkstd[i].z, crlb[i].z, trkmean[i].z, truepos[i].z);
output.push_back(truepos[i].z);
output.push_back(trkmean[i].x);
output.push_back(trkstd[i].x);
output.push_back(trkmean[i].z);
output.push_back(trkstd[i].z);
output.push_back(crlb[i].x);
output.push_back(crlb[i].z);
mean_std += trkstd[i];
}
dbgprintf("mean z err: %f\n", (mean_std/nstep).z);
WriteImageAsCSV( SPrintf("%s_%d_flags%d_cl%d.txt",name, weightMode, extraFlags,clean_lut).c_str(), &output[0], 7, output.size()/7);
lut.free();
rescaledLUT.free();
}
