dmtxdecode.c

Go to the documentation of this file.

 
#include <assert.h>
#include <math.h>
#include <stdio.h>  // for snprintf
#include <stdlib.h>
#include <string.h>
 
#include "dmtx.h"
#include "dmtxstatic.h"
 
extern DmtxDecode *dmtxDecodeCreate(DmtxImage *img, int scale)
{
    DmtxDecode *dec;
    int width, height;
 
    dec = (DmtxDecode *)calloc(1, sizeof(DmtxDecode));
    if (dec == NULL) {
        return NULL;
    }
 
    width = dmtxImageGetProp(img, DmtxPropWidth) / scale;
    height = dmtxImageGetProp(img, DmtxPropHeight) / scale;
 
    dec->fnc1 = DmtxUndefined;
 
    dec->edgeMin = DmtxUndefined;
    dec->edgeMax = DmtxUndefined;
    dec->scanGap = 1;
    dec->squareDevn = cos(50 * (M_PI / 180));
    dec->sizeIdxExpected = DmtxSymbolShapeAuto;
    dec->edgeThresh = 10;
 
    dec->xMin = 0;
    dec->xMax = width - 1;
    dec->yMin = 0;
    dec->yMax = height - 1;
    dec->scale = scale;
 
    dec->cache = (unsigned char *)calloc((size_t)width * height, sizeof(unsigned char));
    if (dec->cache == NULL) {
        free(dec);
        return NULL;
    }
 
    dec->image = img;
    dec->grid = initScanGrid(dec);
 
    return dec;
}
 
extern DmtxPassFail dmtxDecodeDestroy(DmtxDecode **dec)
{
    if (dec == NULL || *dec == NULL) {
        return DmtxFail;
    }
 
    if ((*dec)->cache != NULL) {
        free((*dec)->cache);
    }
 
    free(*dec);
 
    *dec = NULL;
 
    return DmtxPass;
}
 
extern DmtxPassFail dmtxDecodeSetProp(DmtxDecode *dec, int prop, int value)
{
    switch (prop) {
        case DmtxPropEdgeMin:
            dec->edgeMin = value;
            break;
        case DmtxPropEdgeMax:
            dec->edgeMax = value;
            break;
        case DmtxPropScanGap:
            dec->scanGap = value; /* XXX Should this be scaled? */
            break;
        case DmtxPropFnc1:
            dec->fnc1 = value;
            break;
        case DmtxPropSquareDevn:
            dec->squareDevn = cos(value * (M_PI / 180.0));
            break;
        case DmtxPropSymbolSize:
            dec->sizeIdxExpected = value;
            break;
        case DmtxPropEdgeThresh:
            dec->edgeThresh = value;
            break;
        /* Min and Max values arrive unscaled */
        case DmtxPropXmin:
            dec->xMin = value / dec->scale;
            break;
        case DmtxPropXmax:
            dec->xMax = value / dec->scale;
            break;
        case DmtxPropYmin:
            dec->yMin = value / dec->scale;
            break;
        case DmtxPropYmax:
            dec->yMax = value / dec->scale;
            break;
        default:
            break;
    }
 
    if (dec->squareDevn <= 0.0 || dec->squareDevn >= 1.0) {
        return DmtxFail;
    }
 
    if (dec->scanGap < 1) {
        return DmtxFail;
    }
 
    if (dec->edgeThresh < 1 || dec->edgeThresh > 100) {
        return DmtxFail;
    }
 
    /* Reinitialize scangrid in case any inputs changed */
    dec->grid = initScanGrid(dec);
 
    return DmtxPass;
}
 
extern int dmtxDecodeGetProp(DmtxDecode *dec, int prop)
{
    switch (prop) {
        case DmtxPropEdgeMin:
            return dec->edgeMin;
        case DmtxPropEdgeMax:
            return dec->edgeMax;
        case DmtxPropScanGap:
            return dec->scanGap;
        case DmtxPropFnc1:
            return dec->fnc1;
        case DmtxPropSquareDevn:
            return (int)(acos(dec->squareDevn) * 180.0 / M_PI);
        case DmtxPropSymbolSize:
            return dec->sizeIdxExpected;
        case DmtxPropEdgeThresh:
            return dec->edgeThresh;
        case DmtxPropXmin:
            return dec->xMin;
        case DmtxPropXmax:
            return dec->xMax;
        case DmtxPropYmin:
            return dec->yMin;
        case DmtxPropYmax:
            return dec->yMax;
        case DmtxPropScale:
            return dec->scale;
        case DmtxPropWidth:
            return dmtxImageGetProp(dec->image, DmtxPropWidth) / dec->scale;
        case DmtxPropHeight:
            return dmtxImageGetProp(dec->image, DmtxPropHeight) / dec->scale;
        default:
            break;
    }
 
    return DmtxUndefined;
}
 
extern unsigned char *dmtxDecodeGetCache(DmtxDecode *dec, int x, int y)
{
    int width, height;
 
    DmtxAssert(dec != NULL);
 
    /* if(dec.cacheComplete == DmtxFalse)
          CacheImage(); */
 
    width = dmtxDecodeGetProp(dec, DmtxPropWidth);
    height = dmtxDecodeGetProp(dec, DmtxPropHeight);
 
    if (x < 0 || x >= width || y < 0 || y >= height) {
        return NULL;
    }
 
    return &(dec->cache[y * width + x]);
}
 
extern DmtxPassFail dmtxDecodeGetPixelValue(DmtxDecode *dec, int x, int y, int channel, OUT int *value)
{
    int xUnscaled, yUnscaled;
    DmtxPassFail err;
 
    xUnscaled = x * dec->scale;
    yUnscaled = y * dec->scale;
 
    /* Remove spherical lens distortion */
    /* int width, height;
       double radiusPow2, radiusPow4;
       double factor;
       DmtxVector2 pointShifted;
       DmtxVector2 correctedPoint;
 
       width = dmtxImageGetProp(img, DmtxPropWidth);
       height = dmtxImageGetProp(img, DmtxPropHeight);
 
       pointShifted.X = point.X - width/2.0;
       pointShifted.Y = point.Y - height/2.0;
 
       radiusPow2 = pointShifted.X * pointShifted.X + pointShifted.Y * pointShifted.Y;
       radiusPow4 = radiusPow2 * radiusPow2;
 
       factor = 1 + (k1 * radiusPow2) + (k2 * radiusPow4);
 
       correctedPoint.X = pointShifted.X * factor + width/2.0;
       correctedPoint.Y = pointShifted.Y * factor + height/2.0;
 
       return correctedPoint; */
 
    err = dmtxImageGetPixelValue(dec->image, xUnscaled, yUnscaled, channel, value);
 
    return err;
}
 
static void cacheFillQuad(DmtxDecode *dec, DmtxPixelLoc p0, DmtxPixelLoc p1, DmtxPixelLoc p2, DmtxPixelLoc p3)
{
    DmtxBresLine lines[4];
    DmtxPixelLoc pEmpty = {0, 0};
    unsigned char *cache;
    int *scanlineMin, *scanlineMax;
    int minY, maxY, sizeY, posY, posX;
    int i, idx;
 
    lines[0] = bresLineInit(p0, p1, pEmpty);
    lines[1] = bresLineInit(p1, p2, pEmpty);
    lines[2] = bresLineInit(p2, p3, pEmpty);
    lines[3] = bresLineInit(p3, p0, pEmpty);
 
    minY = dec->yMax;
    maxY = 0;
 
    minY = min(minY, p0.y);
    maxY = max(maxY, p0.y);
    minY = min(minY, p1.y);
    maxY = max(maxY, p1.y);
    minY = min(minY, p2.y);
    maxY = max(maxY, p2.y);
    minY = min(minY, p3.y);
    maxY = max(maxY, p3.y);
 
    sizeY = maxY - minY + 1;
 
    scanlineMin = (int *)malloc(sizeY * sizeof(int));
    scanlineMax = (int *)calloc(sizeY, sizeof(int));
 
    DmtxAssert(scanlineMin); /* XXX handle this better */
    DmtxAssert(scanlineMax); /* XXX handle this better */
 
    for (i = 0; i < sizeY; i++) {
        scanlineMin[i] = dec->xMax;
    }
 
    for (i = 0; i < 4; i++) {
        while (lines[i].loc.x != lines[i].loc1.x || lines[i].loc.y != lines[i].loc1.y) {
            idx = lines[i].loc.y - minY;
            scanlineMin[idx] = min(scanlineMin[idx], lines[i].loc.x);
            scanlineMax[idx] = max(scanlineMax[idx], lines[i].loc.x);
            bresLineStep(lines + i, 1, 0);
        }
    }
 
    for (posY = minY; posY < maxY && posY < dec->yMax; posY++) {
        idx = posY - minY;
        for (posX = scanlineMin[idx]; posX < scanlineMax[idx] && posX < dec->xMax; posX++) {
            cache = dmtxDecodeGetCache(dec, posX, posY);
            if (cache != NULL) {
                *cache |= 0x80;
            }
        }
    }
 
    free(scanlineMin);
    free(scanlineMax);
}
 
extern DmtxMessage *dmtxDecodeMatrixRegion(DmtxDecode *dec, DmtxRegion *reg, int fix /*DmtxUndefined*/)
{
    // dmtxLogDebug("libdmtx::dmtxDecodeMatrixRegion()");
    DmtxMessage *msg;
 
    msg = dmtxMessageCreate(reg->sizeIdx, DmtxFormatMatrix);
    if (msg == NULL) {
        return NULL;
    }
 
    if (populateArrayFromMatrix(dec, reg, msg) != DmtxPass) {
        dmtxMessageDestroy(&msg);
        return NULL;
    }
 
    msg->fnc1 = dec->fnc1;
 
    {
        DmtxVector2 topLeft, topRight, bottomLeft, bottomRight;
        DmtxPixelLoc pxTopLeft, pxTopRight, pxBottomLeft, pxBottomRight;
 
        topLeft.x = bottomLeft.x = topLeft.y = topRight.y = -0.1;
        topRight.x = bottomRight.x = bottomLeft.y = bottomRight.y = 1.1;
 
        dmtxMatrix3VMultiplyBy(&topLeft, reg->fit2raw);
        dmtxMatrix3VMultiplyBy(&topRight, reg->fit2raw);
        dmtxMatrix3VMultiplyBy(&bottomLeft, reg->fit2raw);
        dmtxMatrix3VMultiplyBy(&bottomRight, reg->fit2raw);
 
        pxTopLeft.x = (int)(0.5 + topLeft.x);
        pxTopLeft.y = (int)(0.5 + topLeft.y);
        pxBottomLeft.x = (int)(0.5 + bottomLeft.x);
        pxBottomLeft.y = (int)(0.5 + bottomLeft.y);
        pxTopRight.x = (int)(0.5 + topRight.x);
        pxTopRight.y = (int)(0.5 + topRight.y);
        pxBottomRight.x = (int)(0.5 + bottomRight.x);
        pxBottomRight.y = (int)(0.5 + bottomRight.y);
 
        cacheFillQuad(dec, pxTopLeft, pxTopRight, pxBottomRight, pxBottomLeft);
    }
 
    return dmtxDecodePopulatedArray(reg->sizeIdx, msg, fix);
}
 
DmtxMessage *dmtxDecodePopulatedArray(int sizeIdx, INOUT DmtxMessage *msg, int fix /*DmtxUndefined*/)
{
    /*
     * Example msg->array indices for a 12x12 datamatrix.
     *  also, the 'L' color (usually black) is defined as 'DmtxModuleOnRGB'
     *
     * XX    XX    XX    XX    XX    XX
     * XX 00 01 02 03 04 05 06 07 08 09 XX
     * XX 10 11 12 13 14 15 16 17 18 19
     * XX 20 21 22 23 24 25 26 27 28 29 XX
     * XX 30 31 32 33 34 35 36 37 38 39
     * XX 40 41 42 43 44 45 46 47 48 49 XX
     * XX 50 51 52 53 54 55 56 57 58 59
     * XX 60 61 62 63 64 65 66 67 68 69 XX
     * XX 70 71 72 73 74 75 76 77 78 79
     * XX 80 81 82 83 84 85 86 87 88 89 XX
     * XX 90 91 92 93 94 95 96 97 98 99
     * XX XX XX XX XX XX XX XX XX XX XX XX
     *
     */
 
    /* 根据bit数组(array)拼接为code */
    modulePlacementEcc200(msg->array, msg->code, sizeIdx, DmtxModuleOnRed | DmtxModuleOnGreen | DmtxModuleOnBlue);
 
    if (rsDecode(msg->code, sizeIdx, fix) == DmtxFail) {
        dmtxMessageDestroy(&msg);
        msg = NULL;
        return NULL;
    }
 
    if (decodeDataStream(msg, sizeIdx, NULL) == DmtxFail) {
        dmtxMessageDestroy(&msg);
        msg = NULL;
        return NULL;
    }
 
    return msg;
}
 
extern DmtxMessage *dmtxDecodeMosaicRegion(DmtxDecode *dec, DmtxRegion *reg, int fix)
{
    int offset;
    int colorPlane;
    DmtxMessage *oMsg, *rMsg, *gMsg, *bMsg;
 
    colorPlane = reg->flowBegin.plane;
 
    reg->flowBegin.plane = 0; /* kind of a hack */
    rMsg = dmtxDecodeMatrixRegion(dec, reg, fix);
 
    reg->flowBegin.plane = 1; /* kind of a hack */
    gMsg = dmtxDecodeMatrixRegion(dec, reg, fix);
 
    reg->flowBegin.plane = 2; /* kind of a hack */
    bMsg = dmtxDecodeMatrixRegion(dec, reg, fix);
 
    reg->flowBegin.plane = colorPlane;
 
    oMsg = dmtxMessageCreate(reg->sizeIdx, DmtxFormatMosaic);
 
    if (oMsg == NULL || rMsg == NULL || gMsg == NULL || bMsg == NULL) {
        dmtxMessageDestroy(&oMsg);
        dmtxMessageDestroy(&rMsg);
        dmtxMessageDestroy(&gMsg);
        dmtxMessageDestroy(&bMsg);
        return NULL;
    }
 
    offset = 0;
    memcpy(oMsg->output + offset, rMsg->output, rMsg->outputIdx);
    offset += rMsg->outputIdx;
    memcpy(oMsg->output + offset, gMsg->output, gMsg->outputIdx);
    offset += gMsg->outputIdx;
    memcpy(oMsg->output + offset, bMsg->output, bMsg->outputIdx);
    offset += bMsg->outputIdx;
 
    oMsg->outputIdx = offset;
 
    dmtxMessageDestroy(&rMsg);
    dmtxMessageDestroy(&gMsg);
    dmtxMessageDestroy(&bMsg);
 
    return oMsg;
}
 
extern unsigned char *dmtxDecodeCreateDiagnostic(DmtxDecode *dec, int *totalBytes, int *headerBytes, int style)
{
    int i, row, col;
    int width, height;
    int widthDigits, heightDigits;
    int count, channelCount;
    int rgb[3];
    double shade;
    unsigned char *pnm, *output, *cache;
 
    width = dmtxDecodeGetProp(dec, DmtxPropWidth);
    height = dmtxDecodeGetProp(dec, DmtxPropHeight);
    channelCount = dmtxImageGetProp(dec->image, DmtxPropChannelCount);
 
    style = 1; /* this doesn't mean anything yet */
 
    /* Count width digits */
    for (widthDigits = 0, i = width; i > 0; i /= 10) {
        widthDigits++;
    }
 
    /* Count height digits */
    for (heightDigits = 0, i = height; i > 0; i /= 10) {
        heightDigits++;
    }
 
    *headerBytes = widthDigits + heightDigits + 9;
    *totalBytes = *headerBytes + width * height * 3;
 
    pnm = (unsigned char *)malloc(*totalBytes);
    if (pnm == NULL) {
        return NULL;
    }
 
#if defined(_MSC_VER) && (_MSC_VER < 1700)
    count = sprintf_s((char *)pnm, *headerBytes + 1, "P6\n%d %d\n255\n", width, height);
#else
    count = snprintf((char *)pnm, *headerBytes + 1, "P6\n%d %d\n255\n", width, height);
#endif
 
    if (count != *headerBytes) {
        free(pnm);
        return NULL;
    }
 
    output = pnm + (*headerBytes);
    for (row = height - 1; row >= 0; row--) {
        for (col = 0; col < width; col++) {
            cache = dmtxDecodeGetCache(dec, col, row);
            if (cache == NULL) {
                rgb[0] = 0;
                rgb[1] = 0;
                rgb[2] = 128;
            } else if (*cache & 0x40) {
                rgb[0] = 255;
                rgb[1] = 0;
                rgb[2] = 0;
            } else {
                shade = (*cache & 0x80) ? 0.0 : 0.7;
                for (i = 0; i < 3; i++) {
                    if (i < channelCount) {
                        dmtxDecodeGetPixelValue(dec, col, row, i, &rgb[i]);
                    } else {
                        dmtxDecodeGetPixelValue(dec, col, row, 0, &rgb[i]);
                    }
 
                    rgb[i] += (int)(shade * (double)(255 - rgb[i]) + 0.5);
                    if (rgb[i] > 255) {
                        rgb[i] = 255;
                    }
                }
            }
            *(output++) = (unsigned char)rgb[0];
            *(output++) = (unsigned char)rgb[1];
            *(output++) = (unsigned char)rgb[2];
        }
    }
    DmtxAssert(output == pnm + *totalBytes);
 
    return pnm;
}
 
static void tallyModuleJumps(DmtxDecode *dec, DmtxRegion *reg, INOUT int tally[][24], int xOrigin, int yOrigin,
                             int mapWidth, int mapHeight, DmtxDirection dir)
{
    int extent, weight;
    int travelStep;
    int symbolRow, symbolCol;
    int mapRow, mapCol;
    int lineStart, lineStop;
    int travelStart, travelStop;
    int *line, *travel;
    int jumpThreshold;
    int darkOnLight;  // 白底黑码：1，黑底白码：0
    int color;
    int statusPrev, statusModule;
    int tPrev, tModule;
 
    DmtxAssert(dir == DmtxDirUp || dir == DmtxDirLeft || dir == DmtxDirDown || dir == DmtxDirRight);
 
    travelStep = (dir == DmtxDirUp || dir == DmtxDirRight) ? 1 : -1;
 
    /* Abstract row and column progress using pointers to allow grid traversal in all 4 directions using same logic */
 
    if ((dir & DmtxDirHorizontal) != 0x00) {
        line = &symbolRow;
        travel = &symbolCol;
        extent = mapWidth;
        lineStart = yOrigin;
        lineStop = yOrigin + mapHeight;
        travelStart = (travelStep == 1) ? xOrigin - 1 : xOrigin + mapWidth;
        travelStop = (travelStep == 1) ? xOrigin + mapWidth : xOrigin - 1;
    } else {
        DmtxAssert(dir & DmtxDirVertical);
        line = &symbolCol;
        travel = &symbolRow;
        extent = mapHeight;
        lineStart = xOrigin;
        lineStop = xOrigin + mapWidth;
        travelStart = (travelStep == 1) ? yOrigin - 1 : yOrigin + mapHeight;
        travelStop = (travelStep == 1) ? yOrigin + mapHeight : yOrigin - 1;
    }
 
    darkOnLight = (int)(reg->offColor > reg->onColor);
    jumpThreshold = abs((int)(0.4 * (reg->offColor - reg->onColor) + 0.5));
 
    DmtxAssert(jumpThreshold >= 0);
 
    for (*line = lineStart; *line < lineStop; (*line)++) {
        /* Capture tModule for each leading border module as normal but decide status based on predictable barcode
         * border pattern */
 
        *travel = travelStart;
        color = readModuleColor(dec, reg, symbolRow, symbolCol, reg->sizeIdx, reg->flowBegin.plane);
        tModule = (darkOnLight) ? reg->offColor - color : color - reg->offColor;
 
        statusModule = (travelStep == 1 || (*line & 0x01) == 0) ? DmtxModuleOnRGB : DmtxModuleOff;
 
        weight = extent;
 
        while ((*travel += travelStep) != travelStop) {
            tPrev = tModule;
            statusPrev = statusModule;
 
            /* For normal data-bearing modules capture color and decide module status based on comparison to previous
             * "known" module */
 
            color = readModuleColor(dec, reg, symbolRow, symbolCol, reg->sizeIdx, reg->flowBegin.plane);
            tModule = (darkOnLight) ? reg->offColor - color : color - reg->offColor;
 
            /* 和上一次的结果数据对比，如果在加减Threshold后满足条件，那么认为确实有一次跳变 */
            if (statusPrev == DmtxModuleOnRGB) {
                if (tModule < tPrev - jumpThreshold) {
                    statusModule = DmtxModuleOff;
                } else {
                    statusModule = DmtxModuleOnRGB;
                }
            } else if (statusPrev == DmtxModuleOff) {
                if (tModule > tPrev + jumpThreshold) {
                    statusModule = DmtxModuleOnRGB;
                } else {
                    statusModule = DmtxModuleOff;
                }
            }
 
            mapRow = symbolRow - yOrigin;
            mapCol = symbolCol - xOrigin;
            DmtxAssert(mapRow < 24 && mapCol < 24);
 
            if (statusModule == DmtxModuleOnRGB) {
                tally[mapRow][mapCol] += (2 * weight);  // 对于bit为1的码元位置进行记录
            }
 
            weight--;
        }
 
        DmtxAssert(weight == 0);
    }
}
 
static DmtxPassFail populateArrayFromMatrix(DmtxDecode *dec, DmtxRegion *reg, OUT DmtxMessage *msg)
{
    // dmtxLogDebug("libdmtx::populateArrayFromMatrix()");
    int weightFactor;
    int mapWidth, mapHeight;
    int xRegionTotal, yRegionTotal;
    int xRegionCount, yRegionCount;
    int xOrigin, yOrigin;
    int mapCol, mapRow;
    int colTmp, rowTmp, idx;
    int tally[24][24]; /* 单个区块最大不会超过24×24，直接以最大分配 */
 
    /* memset(msg->array, 0x00, msg->arraySize); */
 
    /* 获取条形码中两个方向的区块数。当码元数目超过26×26（对于数据，码元数目超过24×24）时，它会划分为区块 */
    xRegionTotal = dmtxGetSymbolAttribute(DmtxSymAttribHorizDataRegions, reg->sizeIdx);
    yRegionTotal = dmtxGetSymbolAttribute(DmtxSymAttribVertDataRegions, reg->sizeIdx);
 
    /* 获取区块数据区尺寸(不包括边界模块) */
    mapWidth = dmtxGetSymbolAttribute(DmtxSymAttribDataRegionCols, reg->sizeIdx);
    mapHeight = dmtxGetSymbolAttribute(DmtxSymAttribDataRegionRows, reg->sizeIdx);
 
    weightFactor = 2 * (mapHeight + mapWidth + 2);
    DmtxAssert(weightFactor > 0);
 
    // dmtxLogInfo("libdmtx::populateArrayFromMatrix::reg->sizeIdx: %d", reg->sizeIdx);
    // dmtxLogInfo("libdmtx::populateArrayFromMatrix::reg->flowBegin.plane: %d", reg->flowBegin.plane);
    // dmtxLogInfo("libdmtx::populateArrayFromMatrix::reg->onColor: %d", reg->onColor);
    // dmtxLogInfo("libdmtx::populateArrayFromMatrix::reg->offColor: %d", reg->offColor);
    // dmtxLogInfo("libdmtx::populateArrayFromMatrix::xRegionTotal: %d", xRegionTotal);
    // dmtxLogInfo("libdmtx::populateArrayFromMatrix::yRegionTotal: %d", yRegionTotal);
    // dmtxLogInfo("libdmtx::populateArrayFromMatrix::mapWidth: %d", mapWidth);
    // dmtxLogInfo("libdmtx::populateArrayFromMatrix::mapHeight: %d", mapHeight);
    // dmtxLogInfo("libdmtx::populateArrayFromMatrix::weightFactor: %d", weightFactor);
    // reg->fit2raw[1][0] = 0;
    // reg->fit2raw[0][1] = 0;
    // reg->fit2raw[0][2] = 0;
    // reg->fit2raw[2][2] = 1;
    // reg->fit2raw[1][2] = 0;
    // reg->fit2raw[2][0] = 10;  // translation
    // reg->fit2raw[2][1] = 10;  // translation
    // reg->fit2raw[0][0] = 60;  // scale
    // reg->fit2raw[1][1] = 60;  // scale
    // dmtxMatrix3Print(reg->fit2raw);
 
    /* 每个方向上每个区域的计数模块变化 Tally module changes for each region in each direction */
    for (yRegionCount = 0; yRegionCount < yRegionTotal; yRegionCount++) {
        /* 在符号坐标中映射区域原点的Y位置 Y location of mapping region origin in symbol coordinates */
        yOrigin = yRegionCount * (mapHeight + 2) + 1;
 
        for (xRegionCount = 0; xRegionCount < xRegionTotal; xRegionCount++) {
            /* 在符号坐标中映射区域原点的X位置 X location of mapping region origin in symbol coordinates */
            xOrigin = xRegionCount * (mapWidth + 2) + 1;
 
            // dmtxLogInfo("libdmtx::populateArrayFromMatrix::xOrigin: %d", xOrigin);
 
            memset(tally, 0x00, sizeof(int) * 24 * 24);
            tallyModuleJumps(dec, reg, tally, xOrigin, yOrigin, mapWidth, mapHeight, DmtxDirUp);
            tallyModuleJumps(dec, reg, tally, xOrigin, yOrigin, mapWidth, mapHeight, DmtxDirLeft);
            tallyModuleJumps(dec, reg, tally, xOrigin, yOrigin, mapWidth, mapHeight, DmtxDirDown);
            tallyModuleJumps(dec, reg, tally, xOrigin, yOrigin, mapWidth, mapHeight, DmtxDirRight);
 
            /* 根据记录内容(tally)更新array的内容 */
            for (mapRow = 0; mapRow < mapHeight; mapRow++) {
                // for(mapRow = mapHeight-1; mapRow >= 0; mapRow--) {
                for (mapCol = 0; mapCol < mapWidth; mapCol++) {
                    rowTmp = (yRegionCount * mapHeight) + mapRow;
                    rowTmp = yRegionTotal * mapHeight - rowTmp - 1;
                    colTmp = (xRegionCount * mapWidth) + mapCol;
                    idx = (rowTmp * xRegionTotal * mapWidth) + colTmp;
 
                    // printf("%c ", tally[mapRow][mapCol] == DmtxModuleOff ? '0' : '1');
                    if (tally[mapRow][mapCol] / (double)weightFactor >= 0.5) {
                        msg->array[idx] = DmtxModuleOnRGB;
                        // printf("1 ");
                    } else {
                        msg->array[idx] = DmtxModuleOff;
                        // printf("0 ");
                    }
                    // printf("libdmtx::populateArrayFromMatrix::idx: %d @ (%d,%d)\n", idx, mapCol, mapRow);
 
                    msg->array[idx] |= DmtxModuleAssigned;  // 标记为已分配
                }
                // printf("\n");
            }
        }
    }
 
    return DmtxPass;
}