21 CvPoint fcoord(float fx, float fy);
22 CvPoint coord(int ix, int iy);
23 Sampler(CvMat *_im, CvPoint _o, CvPoint _c, CvPoint _cc);
24 uchar getpixel(int ix, int iy);
25 int isinside(int x, int y);
26 int overlap(Sampler &other);
30 Sampler():im(0),perim(0){}
34 class code { // used in this file only
41 unsigned char cblk[256] = { 34,19,36,36,51,19,51,51,66,19,36,36,66,19,66,66,49,19,36,36,51,19,51,51,49,19,36,36,
42 49,19,49,49,32,19,36,36,51,19,51,51,66,19,36,36,66,19,66,66,32,19,36,36,51,19,51,51,32,19,36,36,32,19,32,32,
43 17,19,36,36,51,19,51,51,66,19,36,36,66,19,66,66,49,19,36,36,51,19,51,51,49,19,36,36,49,19,49,49,17,19,36,36,
44 51,19,51,51,66,19,36,36,66,19,66,66,17,19,36,36,51,19,51,51,17,19,36,36,17,19,17,17,2,19,2,36,2,19,2,51,2,19,
45 2,36,2,19,2,66,2,19,2,36,2,19,2,51,2,19,2,36,2,19,2,49,2,19,2,36,2,19,2,51,2,19,2,36,2,19,2,66,2,19,2,36,2,19,
46 2,51,2,19,2,36,2,19,2,32,2,19,2,36,2,19,2,51,2,19,2,36,2,19,2,66,2,19,2,36,2,19,2,51,2,19,2,36,2,19,2,49,2,19,
47 2,36,2,19,2,51,2,19,2,36,2,19,2,66,2,19,2,36,2,19,2,51,2,19,2,36,2,19,2,34 };
48 unsigned char ccblk[256] = { 34,17,2,17,19,19,2,17,36,36,2,36,19,19,2,17,51,51,2,51,19,19,2,51,36,36,2,36,19,19,2,17,
49 66,66,2,66,19,19,2,66,36,36,2,36,19,19,2,66,51,51,2,51,19,19,2,51,36,36,2,36,19,19,2,17,49,49,2,49,19,19,2,49,36,
50 36,2,36,19,19,2,49,51,51,2,51,19,19,2,51,36,36,2,36,19,19,2,49,66,66,2,66,19,19,2,66,36,36,2,36,19,19,2,66,51,51,
51 2,51,19,19,2,51,36,36,2,36,19,19,2,17,32,32,2,32,19,19,2,32,36,36,2,36,19,19,2,32,51,51,2,51,19,19,2,51,36,36,2,
52 36,19,19,2,32,66,66,2,66,19,19,2,66,36,36,2,36,19,19,2,66,51,51,2,51,19,19,2,51,36,36,2,36,19,19,2,32,49,49,2,49,
53 19,19,2,49,36,36,2,36,19,19,2,49,51,51,2,51,19,19,2,51,36,36,2,36,19,19,2,49,66,66,2,66,19,19,2,66,36,36,2,36,19,
54 19,2,66,51,51,2,51,19,19,2,51,36,36,2,36,19,19,2,34 };
55 static const CvPoint pickup[64] = { {7,6},{8,6},{7,5},{8,5},{1,5},{7,4},{8,4},{1,4},{1,8},{2,8},{1,7},{2,7},{3,7},
56 {1,6},{2,6},{3,6},{3,2},{4,2},{3,1},{4,1},{5,1},{3,8},{4,8},{5,8},{6,1},{7,1},{6,8},{7,8},{8,8},{6,7},{7,7},{8,7},
57 {4,7},{5,7},{4,6},{5,6},{6,6},{4,5},{5,5},{6,5},{2,5},{3,5},{2,4},{3,4},{4,4},{2,3},{3,3},{4,3},{8,3},{1,3},{8,2},
58 {1,2},{2,2},{8,1},{1,1},{2,1},{5,4},{6,4},{5,3},{6,3},{7,3},{5,2},{6,2},{7,2} };
59 static const uchar Alog[256] = { 1,2,4,8,16,32,64,128,45,90,180,69,138,57,114,228,229,231,227,235,251,219,155,27,
60 54,108,216,157,23,46,92,184,93,186,89,178,73,146,9,18,36,72,144,13,26,52,104,208,141,55,110,220,149,7,14,28,
61 56,112,224,237,247,195,171,123,246,193,175,115,230,225,239,243,203,187,91,182,65,130,41,82,164,101,202,185,95,
62 190,81,162,105,210,137,63,126,252,213,135,35,70,140,53,106,212,133,39,78,156,21,42,84,168,125,250,217,159,19,
63 38,76,152,29,58,116,232,253,215,131,43,86,172,117,234,249,223,147,11,22,44,88,176,77,154,25,50,100,200,189,87,
64 174,113,226,233,255,211,139,59,118,236,245,199,163,107,214,129,47,94,188,85,170,121,242,201,191,83,166,97,194,
65 169,127,254,209,143,51,102,204,181,71,142,49,98,196,165,103,206,177,79,158,17,34,68,136,61,122,244,197,167,99,
66 198,161,111,222,145,15,30,60,120,240,205,183,67,134,33,66,132,37,74,148,5,10,20,40,80,160,109,218,153,31,62,
67 124,248,221,151,3,6,12,24,48,96,192,173,119,238,241,207,179,75,150,1 };
68 static const uchar Log[256] = { (uchar)-255,255,1,240,2,225,241,53,3,38,226,133,242,43,54,210,4,195,39,
69 114,227,106,134,28,243,140,44,23,55,118,211,234,5,219,196,96,40,222,115,103,228,78,107,125,
70 135,8,29,162,244,186,141,180,45,99,24,49,56,13,119,153,212,199,235,91,6,76,220,217,197,11,97,
71 184,41,36,223,253,116,138,104,193,229,86,79,171,108,165,126,145,136,34,9,74,30,32,163,84,245,
72 173,187,204,142,81,181,190,46,88,100,159,25,231,50,207,57,147,14,67,120,128,154,248,213,167,
73 200,63,236,110,92,176,7,161,77,124,221,102,218,95,198,90,12,152,98,48,185,179,42,209,37,132,
74 224,52,254,239,117,233,139,22,105,27,194,113,230,206,87,158,80,189,172,203,109,175,166,62,127,
75 247,146,66,137,192,35,252,10,183,75,216,31,83,33,73,164,144,85,170,246,65,174,61,188,202,205,
76 157,143,169,82,72,182,215,191,251,47,178,89,151,101,94,160,123,26,112,232,21,51,238,208,131,
77 58,69,148,18,15,16,68,17,121,149,129,19,155,59,249,70,214,250,168,71,201,156,64,60,237,130,
78 111,20,93,122,177,150 };
80 #define dethresh 0.92f
81 #define eincO (2 * dethresh) // e increment orthogonal
82 #define eincD (1.414f * dethresh) // e increment diagonal
84 static const float eincs[] = {
91 #define Ki(x) _mm_set_epi32((x),(x),(x),(x))
92 #define Kf(x) _mm_set_ps((x),(x),(x),(x))
94 static const int CV_DECL_ALIGNED(16) absmask[] = {0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff};
95 #define _mm_abs_ps(x) _mm_and_ps((x), *(const __m128*)absmask)
97 static void writexy(CvMat *m, int r, CvPoint p)
99 int *pdst = (int*)cvPtr2D(m, r, 0);
104 Sampler::Sampler(CvMat *_im, CvPoint _o, CvPoint _c, CvPoint _cc)
110 perim = cvCreateMat(4, 1, CV_32SC2);
111 writexy(perim, 0, fcoord(-.2f,-.2f));
112 writexy(perim, 1, fcoord(-.2f,1.2f));
113 writexy(perim, 2, fcoord(1.2f,1.2f));
114 writexy(perim, 3, fcoord(1.2f,-.2f));
115 // printf("Sampler %d,%d %d,%d %d,%d\n", o.x, o.y, c.x, c.y, cc.x, cc.y);
118 CvPoint Sampler::fcoord(float fx, float fy)
121 r.x = (int)(o.x + fx * (cc.x - o.x) + fy * (c.x - o.x));
122 r.y = (int)(o.y + fx * (cc.y - o.y) + fy * (c.y - o.y));
126 CvPoint Sampler::coord(int ix, int iy)
128 return fcoord(0.05f + 0.1f * ix, 0.05f + 0.1f * iy);
131 uchar Sampler::getpixel(int ix, int iy)
133 CvPoint pt = coord(ix, iy);
134 if ((0 <= pt.x) && (pt.x < im->cols) && (0 <= pt.y) && (pt.y < im->rows))
135 return *cvPtr2D(im, pt.y, pt.x);
140 int Sampler::isinside(int x, int y)
145 if ((0 <= pt.x) && (pt.x < im->cols) && (0 <= pt.y) && (pt.y < im->rows))
146 return cvPointPolygonTest(perim, pt, 0) < 0;
151 int Sampler::overlap(Sampler &other)
153 for (int i = 0; i < 4; i++) {
155 p = cvGet2D(other.perim, i, 0);
156 if (isinside((int)p.val[0], (int)p.val[1]))
158 p = cvGet2D(perim, i, 0);
159 if (other.isinside((int)p.val[0], (int)p.val[1]))
165 int Sampler::hasbars()
167 return getpixel(9, 1) > getpixel(9, 0);
170 void Sampler::timing()
172 /*uchar light, dark = getpixel(9, 0);
173 for (int i = 1; i < 3; i += 2) {
174 light = getpixel(9, i);
175 // if (light <= dark)
177 dark = getpixel(9, i + 1);
183 CvMat *Sampler::extract()
185 // return a 10x10 CvMat for the current contents, 0 is black, 255 is white
186 // Sampler has (0,0) at bottom left, so invert Y
187 CvMat *r = cvCreateMat(10, 10, CV_8UC1);
188 for (int x = 0; x < 10; x++)
189 for (int y = 0; y < 10; y++)
190 *cvPtr2D(r, 9 - y, x) = (getpixel(x, y) < 128) ? 0 : 255;
195 static void apron(CvMat *v)
199 memset(cvPtr2D(v, 0, 0), 0x22, c);
200 memset(cvPtr2D(v, 1, 0), 0x22, c);
201 memset(cvPtr2D(v, r - 2, 0), 0x22, c);
202 memset(cvPtr2D(v, r - 1, 0), 0x22, c);
204 for (y = 2; y < r - 2; y++) {
205 uchar *lp = cvPtr2D(v, y, 0);
213 static void cfollow(CvMat *src, CvMat *dst)
216 uchar *vpd = cvPtr2D(src, 0, 0);
217 for (sy = 0; sy < src->rows; sy++) {
218 short *wr = (short*)cvPtr2D(dst, sy, 0);
219 for (sx = 0; sx < src->cols; sx++) {
227 dir = vpd[y * src->step + x];
228 int xd = ((dir & 0xf) - 2);
229 int yd = ((dir >> 4) - 2);
230 e += (dir == 0x22) ? 999 : ((dir & 1) ? eincD : eincO);
234 float d = (float)(((x - sx) * (x - sx)) + ((y - sy) * (y - sy)));
235 ontrack = d > (e * e);
238 if ((24 <= e) && (e < 999)) {
239 // printf("sx=%d, sy=%d, x=%d, y=%d\n", sx, sy, x, y);
240 *wr++ = (short)(x - sx);
241 *wr++ = (short)(y - sy);
250 static uchar gf256mul(uchar a, uchar b)
252 return Alog[(Log[a] + Log[b]) % 255];
255 static int decode(Sampler &sa, code &cc)
257 uchar binary[8] = {0,0,0,0,0,0,0,0};
263 for (int i = 0; i < 64; i++)
264 sum += sa.getpixel(1 + (i & 7), 1 + (i >> 3));
265 uchar mean = (uchar)(sum / 64);
266 for (int i = 0; i < 64; i++) {
267 b = (b << 1) + (sa.getpixel(pickup[i].x, pickup[i].y) <= mean);
274 // Compute the 5 RS codewords for the 3 datawords
276 uchar c[5] = {0,0,0,0,0};
278 uchar a[5] = {228, 48, 15, 111, 62};
280 for (int i = 0; i < 3; i++) {
281 uchar t = binary[i] ^ c[4];
282 for (int j = k - 1; j != -1; j--) {
286 c[j] = gf256mul(t, a[j]);
288 c[j] = c[j - 1] ^ c[j];
293 if ((c[4] == binary[3]) &&
294 (c[3] == binary[4]) &&
295 (c[2] == binary[5]) &&
296 (c[1] == binary[6]) &&
297 (c[0] == binary[7])) {
298 uchar x = 0xff & (binary[0] - 1);
299 uchar y = 0xff & (binary[1] - 1);
300 uchar z = 0xff & (binary[2] - 1);
306 cc.original = sa.extract();
313 static deque<CvPoint> trailto(CvMat *v, int x, int y, CvMat *terminal)
316 /* Return the last 10th of the trail of points following v from (x,y)
320 int ex = x + ((short*)cvPtr2D(terminal, y, x))[0];
321 int ey = y + ((short*)cvPtr2D(terminal, y, x))[1];
323 while ((x != ex) || (y != ey)) {
327 int dir = *cvPtr2D(v, y, x);
328 int xd = ((dir & 0xf) - 2);
329 int yd = ((dir >> 4) - 2);
334 int l = (int)(r.size() * 9 / 10);
341 deque <CvDataMatrixCode> cvFindDataMatrix(CvMat *im)
347 #define SAMESIZE(nm, ty) CvMat *nm = cvCreateMat(r, c, ty);
349 SAMESIZE(thresh, CV_8UC1)
350 SAMESIZE(vecpic, CV_8UC1)
351 SAMESIZE(vc, CV_8UC1)
352 SAMESIZE(vcc, CV_8UC1)
353 SAMESIZE(cxy, CV_16SC2)
354 SAMESIZE(ccxy, CV_16SC2)
356 cvAdaptiveThreshold(im, thresh, 255.0, CV_ADAPTIVE_THRESH_MEAN_C, CV_THRESH_BINARY, 13);
359 int sstride = thresh->step;
360 int sw = thresh->cols; // source width
361 for (y = 2; y < thresh->rows - 2; y++) {
362 uchar *ps = cvPtr2D(thresh, y, 0);
363 uchar *pd = cvPtr2D(vecpic, y, 0);
364 uchar *pvc = cvPtr2D(vc, y, 0);
365 uchar *pvcc = cvPtr2D(vcc, y, 0);
366 for (x = 0; x < sw; x++) {
368 (0x01 & ps[-2 * sstride]) |
369 (0x02 & ps[-sstride + 1]) |
371 (0x08 & ps[sstride + 1]) |
372 (0x10 & ps[2 * sstride]) |
373 (0x20 & ps[sstride - 1]) |
375 (0x80 & ps[-sstride -1]);
389 deque <CvPoint> candidates;
392 int rows = cxy->rows;
393 int cols = cxy->cols;
394 for (y = 0; y < rows; y++) {
395 const short *cd = (const short*)cvPtr2D(cxy, y, 0);
396 const short *ccd = (const short*)cvPtr2D(ccxy, y, 0);
397 for (x = 0; x < cols; x += 4, cd += 8, ccd += 8) {
398 __m128i v = _mm_loadu_si128((const __m128i*)cd);
399 __m128 cyxyxA = _mm_cvtepi32_ps(_mm_srai_epi32(_mm_unpacklo_epi16(v, v), 16));
400 __m128 cyxyxB = _mm_cvtepi32_ps(_mm_srai_epi32(_mm_unpackhi_epi16(v, v), 16));
401 __m128 cx = _mm_shuffle_ps(cyxyxA, cyxyxB, _MM_SHUFFLE(2, 0, 2, 0));
402 __m128 cy = _mm_shuffle_ps(cyxyxA, cyxyxB, _MM_SHUFFLE(3, 1, 3, 1));
403 __m128 cmag = _mm_sqrt_ps(_mm_add_ps(_mm_mul_ps(cx, cx), _mm_mul_ps(cy, cy)));
404 __m128 crmag = _mm_rcp_ps(cmag);
405 __m128 ncx = _mm_mul_ps(cx, crmag);
406 __m128 ncy = _mm_mul_ps(cy, crmag);
408 v = _mm_loadu_si128((const __m128i*)ccd);
409 __m128 ccyxyxA = _mm_cvtepi32_ps(_mm_srai_epi32(_mm_unpacklo_epi16(v, v), 16));
410 __m128 ccyxyxB = _mm_cvtepi32_ps(_mm_srai_epi32(_mm_unpackhi_epi16(v, v), 16));
411 __m128 ccx = _mm_shuffle_ps(ccyxyxA, ccyxyxB, _MM_SHUFFLE(2, 0, 2, 0));
412 __m128 ccy = _mm_shuffle_ps(ccyxyxA, ccyxyxB, _MM_SHUFFLE(3, 1, 3, 1));
413 __m128 ccmag = _mm_sqrt_ps(_mm_add_ps(_mm_mul_ps(ccx, ccx), _mm_mul_ps(ccy, ccy)));
414 __m128 ccrmag = _mm_rcp_ps(ccmag);
415 __m128 nccx = _mm_mul_ps(ccx, ccrmag);
416 __m128 nccy = _mm_mul_ps(ccy, ccrmag);
418 __m128 dot = _mm_mul_ps(_mm_mul_ps(ncx, nccx), _mm_mul_ps(ncy, nccy));
419 // iscand = (cmag > 30) & (ccmag > 30) & (numpy.minimum(cmag, ccmag) * 1.1 > numpy.maximum(cmag, ccmag)) & (abs(dot) < 0.25)
420 __m128 iscand = _mm_and_ps(_mm_cmpgt_ps(cmag, Kf(30)), _mm_cmpgt_ps(ccmag, Kf(30)));
422 iscand = _mm_and_ps(iscand, _mm_cmpgt_ps(_mm_mul_ps(_mm_min_ps(cmag, ccmag), Kf(1.1f)), _mm_max_ps(cmag, ccmag)));
423 iscand = _mm_and_ps(iscand, _mm_cmplt_ps(_mm_abs_ps(dot), Kf(0.25f)));
425 unsigned int CV_DECL_ALIGNED(16) result[4];
426 _mm_store_ps((float*)result, iscand);
429 for (ix = 0; ix < 4; ix++) {
433 candidates.push_back(np);
442 while (!candidates.empty()) {
443 CvPoint o = candidates.front();
444 candidates.pop_front();
445 deque<CvPoint> ptc = trailto(vc, o.x, o.y, cxy);
446 deque<CvPoint> ptcc = trailto(vcc, o.x, o.y, ccxy);
447 for (j = 0; j < ptc.size(); j++) {
448 for (k = 0; k < ptcc.size(); k++) {
450 Sampler sa(im, o, ptc[j], ptcc[k]);
451 for (i = 0; i < codes.size(); i++) {
452 if (sa.overlap(codes[i].sa))
454 cvReleaseMat(&sa.perim);
458 if (codes.size() > 0) {
459 //printf("searching for more\n");
461 if (decode(sa, cc)) {
466 cvReleaseMat(&sa.perim);
469 endo: ; // end search for this o
472 cvReleaseMat(&thresh);
473 cvReleaseMat(&vecpic);
479 deque <CvDataMatrixCode> rc;
480 for (i = 0; i < codes.size(); i++) {
482 strcpy(cc.msg, codes[i].msg);
483 cc.original = codes[i].original;
484 cc.corners = codes[i].sa.perim;
489 deque <CvDataMatrixCode> rc;
494 #include <opencv2/imgproc/imgproc.hpp>
499 void findDataMatrix(InputArray _image,
500 vector<string>& codes,
501 OutputArray _corners,
502 OutputArrayOfArrays _dmtx)
504 Mat image = _image.getMat();
506 deque <CvDataMatrixCode> rc = cvFindDataMatrix(&m);
507 int i, n = (int)rc.size();
510 if( _corners.needed() )
512 _corners.create(n, 4, CV_32SC2);
513 corners = _corners.getMat();
517 _dmtx.create(n, 1, CV_8U);
521 for( i = 0; i < n; i++ )
523 CvDataMatrixCode& rc_i = rc[i];
524 codes[i] = string(rc_i.msg);
528 const Point* srcpt = (Point*)rc_i.corners->data.ptr;
529 Point* dstpt = (Point*)corners.ptr(i);
530 for( int k = 0; k < 4; k++ )
533 cvReleaseMat(&rc_i.corners);
537 _dmtx.create(rc_i.original->rows, rc_i.original->cols, rc_i.original->type, i);
538 Mat dst = _dmtx.getMat(i);
539 Mat(rc_i.original).copyTo(dst);
541 cvReleaseMat(&rc_i.original);
545 void drawDataMatrixCodes(InputOutputArray _image,
546 const vector<string>& codes,
549 Mat image = _image.getMat();
550 Mat corners = _corners.getMat();
551 int i, n = corners.rows;
555 CV_Assert( corners.depth() == CV_32S &&
556 corners.cols*corners.channels() == 8 &&
557 n == (int)codes.size() );
560 for( i = 0; i < n; i++ )
564 const Point* pt = (const Point*)corners.ptr(i);
566 for( int k = 0; k < 4; k++ )
567 line(image, pt[k], pt[(k+1)%4], c);
569 //Size sz = getTextSize(code_text, CV_FONT_HERSHEY_SIMPLEX, 1, 1, &baseline);
570 putText(image, codes[i], pt[0], CV_FONT_HERSHEY_SIMPLEX, 0.8, c2, 1, CV_AA, false);