// For only version 1 which has no Alignement Patterns
        /*	SamplingGrid getSamplingGrid1(FinderPattern finderPattern) {
        int sqrtNumArea = 1;
        int sqrtNumModules = finderPattern.getSqrtNumModules(); //get nummber of modules at side
        int sqrtNumAreaModules = sqrtNumModules / sqrtNumArea;
        Point[] centers = finderPattern.getCenter();
        int logicalDistance = 14;
        SamplingGrid samplingGrid = new SamplingGrid(sqrtNumArea);
        Line baseLineX, baseLineY, gridLineX, gridLineY;

        ModulePitch modulePitch = new ModulePitch(); //store (up,left) order
        modulePitch.top = getAreaModulePitch(centers[0], centers[1], logicalDistance);
        modulePitch.left = getAreaModulePitch(centers[0], centers[2], logicalDistance);

        //X軸に垂直の基線(一般に縦)
        baseLineX = new Line(
        finderPattern.getCenter(FinderPattern.UL),
        finderPattern.getCenter(FinderPattern.DL));

        Axis axis = new Axis(finderPattern.getAngle(), modulePitch.top);
        axis.setOrigin(baseLineX.getP1());
        baseLineX.setP1(axis.translate(-3, -3));

        axis.setModulePitch(modulePitch.left);
        axis.setOrigin(baseLineX.getP2());
        baseLineX.setP2(axis.translate(-3, 3));

        //Y軸に垂直の基線(一般に横)
        baseLineY =
        new Line(finderPattern.getCenter(FinderPattern.UL),
        finderPattern.getCenter(FinderPattern.UR));

        axis.setModulePitch(modulePitch.left);
        axis.setOrigin(baseLineY.getP1());
        baseLineY.setP1(axis.translate(-3, -3));

        axis.setModulePitch(modulePitch.left);
        axis.setOrigin(baseLineY.getP2());
        baseLineY.setP2(axis.translate(3, -3));

        //baseLineX.translate(1,1);
        //baseLineY.translate(1,1);

        samplingGrid.initGrid(0, 0, sqrtNumAreaModules, sqrtNumAreaModules);

        for (int i = 0; i < sqrtNumAreaModules; i++) {

        gridLineX = new Line(baseLineX.getP1(), baseLineX.getP2());

        axis.setOrigin(gridLineX.getP1());
        axis.setModulePitch(modulePitch.top);
        gridLineX.setP1(axis.translate(i,0));

        axis.setOrigin(gridLineX.getP2());
        axis.setModulePitch(modulePitch.top);
        gridLineX.setP2(axis.translate(i,0));

        gridLineY = new Line(baseLineY.getP1(), baseLineY.getP2());
        axis.setOrigin(gridLineY.getP1());
        axis.setModulePitch(modulePitch.left);
        gridLineY.setP1(axis.translate(0,i));

        axis.setOrigin(gridLineY.getP2());
        axis.setModulePitch(modulePitch.left);
        gridLineY.setP2(axis.translate(0,i));

        samplingGrid.setXLine(0,0,i,gridLineX);
        samplingGrid.setYLine(0,0,i,gridLineY);
        }
        for (int ay = 0; ay < samplingGrid.getHeight(); ay++) {
        for (int ax = 0; ax < samplingGrid.getWidth();ax++) {
        canvas.drawLines(samplingGrid.getXLines(ax,ay), Color.BLUE);
        canvas.drawLines(samplingGrid.getYLines(ax,ay), Color.BLUE);
        }
        }
        return samplingGrid;
        }*/
        //sampllingGrid[areaX][areaY][direction(x=0,y=1)][EachLines]
        /*	SamplingGrid getSamplingGrid2_6(FinderPattern finderPattern, AlignmentPattern alignmentPattern) {

        Point centers[][] = alignmentPattern.getCenter();
        centers[0][0] = finderPattern.getCenter(FinderPattern.UL);
        centers[1][0] = finderPattern.getCenter(FinderPattern.UR);
        centers[0][1] = finderPattern.getCenter(FinderPattern.DL);
        int sqrtNumModules = finderPattern.getSqrtNumModules(); //一辺当たりのモジュール数を得る

        SamplingGrid samplingGrid = new SamplingGrid(1);
        Line baseLineX, baseLineY, gridLineX, gridLineY;

        int logicalDistance = alignmentPattern.getLogicalDistance();
        Axis axis = new Axis(finderPattern.getAngle(), finderPattern.getModuleSize());

        ModulePitch modulePitch = new ModulePitch(); //top left bottom rightの順に格納

        modulePitch.top = getAreaModulePitch(centers[0][0], centers[1][0], logicalDistance + 6);
        modulePitch.left = getAreaModulePitch(centers[0][0], centers[0][1], logicalDistance + 6);
        axis.setModulePitch(modulePitch.top);
        axis.setOrigin(centers[0][1]);
        modulePitch.bottom = getAreaModulePitch(axis.translate(0, -3), centers[1][1], logicalDistance + 3);
        axis.setModulePitch(modulePitch.left);
        axis.setOrigin(centers[1][0]);
        modulePitch.right = getAreaModulePitch(axis.translate(-3, 0), centers[1][1], logicalDistance + 3);

        //X軸に垂直の基線(一般に縦)
        baseLineX = new Line();
        baseLineY = new Line();

        axis.setOrigin(centers[0][0]);
        modulePitch.top = getAreaModulePitch(centers[0][0], centers[1][0], logicalDistance + 6);
        modulePitch.left = getAreaModulePitch(centers[0][0], centers[0][1], logicalDistance + 6);
        axis.setModulePitch(modulePitch.top);
        axis.setOrigin(centers[0][1]);
        modulePitch.bottom = getAreaModulePitch(axis.translate(0,-3), centers[1][1], logicalDistance + 3);
        axis.setModulePitch(modulePitch.left);
        axis.setOrigin(centers[1][0]);
        modulePitch.right = getAreaModulePitch(axis.translate(-3,0), centers[1][1], logicalDistance + 3);

        axis.setOrigin(centers[0][0]);
        axis.setModulePitch(modulePitch.top);
        baseLineX.setP1(axis.translate(-3,-3));

        axis.setModulePitch(modulePitch.left);
        baseLineY.setP1(axis.translate(-3,-3));

        axis.setOrigin(centers[0][1]);
        axis.setModulePitch(modulePitch.bottom);
        baseLineX.setP2(axis.translate(-3,3));

        axis.setOrigin(centers[1][0]);
        axis.setModulePitch(modulePitch.right);
        baseLineY.setP2(axis.translate(3,-3));

        baseLineX.translate(1,1);
        baseLineY.translate(1,1);

        samplingGrid.initGrid(0, 0, sqrtNumModules, sqrtNumModules);

        for (int i = 0; i < sqrtNumModules; i++) {
        gridLineX = new Line(baseLineX.getP1(), baseLineX.getP2());

        axis.setOrigin(gridLineX.getP1());
        axis.setModulePitch(modulePitch.top);
        gridLineX.setP1(axis.translate(i,0));

        axis.setOrigin(gridLineX.getP2());
        axis.setModulePitch(modulePitch.bottom);
        gridLineX.setP2(axis.translate(i,0));

        gridLineY = new Line(baseLineY.getP1(), baseLineY.getP2());

        axis.setOrigin(gridLineY.getP1());
        axis.setModulePitch(modulePitch.left);
        gridLineY.setP1(axis.translate(0,i));

        axis.setOrigin(gridLineY.getP2());
        axis.setModulePitch(modulePitch.right);
        gridLineY.setP2(axis.translate(0,i));

        samplingGrid.setXLine(0,0,i,gridLineX);
        samplingGrid.setYLine(0,0,i,gridLineY);

        }

        for (int ay = 0; ay < samplingGrid.getHeight(); ay++) {
        for (int ax = 0; ax < samplingGrid.getWidth();ax++) {
        canvas.drawLines(samplingGrid.getXLines(ax,ay), java.awt.Color.BLUE);
        canvas.drawLines(samplingGrid.getYLines(ax,ay), java.awt.Color.BLUE);
        }
        }
        return samplingGrid;
        }

        //for version 7-13
        SamplingGrid getSamplingGrid7_13(FinderPattern finderPattern, AlignmentPattern alignmentPattern) {

        Point centers[][] = alignmentPattern.getCenter();
        centers[0][0] = finderPattern.getCenter(FinderPattern.UL);
        centers[2][0] = finderPattern.getCenter(FinderPattern.UR);
        centers[0][2] = finderPattern.getCenter(FinderPattern.DL);
        int sqrtNumModules = finderPattern.getSqrtNumModules(); //一辺当たりのモジュール数を得る
        int sqrtNumArea = 2;
        int sqrtNumAreaModules = sqrtNumModules / sqrtNumArea;
        sqrtNumAreaModules++;
        SamplingGrid samplingGrid = new SamplingGrid(sqrtNumArea);
        Line baseLineX, baseLineY, gridLineX, gridLineY;

        int logicalDistance = alignmentPattern.getLogicalDistance();
        Axis axis = new Axis(finderPattern.getAngle(), finderPattern.getModuleSize());
        ModulePitch modulePitch;
        for (int ay = 0; ay < sqrtNumArea; ay++) {
        for (int ax = 0; ax < sqrtNumArea; ax++) {
        modulePitch = new ModulePitch(); //top left bottom rightの順に格納
        baseLineX = new Line();
        baseLineY = new Line();
        axis.setModulePitch(finderPattern.getModuleSize());
        if (ax == 0 && ay == 0) {
        axis.setOrigin(centers[0][0]);
        modulePitch.top = getAreaModulePitch(axis.translate(0,3), centers[1][0], logicalDistance + 3);
        modulePitch.left = getAreaModulePitch(axis.translate(3,0), centers[0][1], logicalDistance + 3);
        axis.setModulePitch(modulePitch.top);
        modulePitch.bottom = getAreaModulePitch(centers[0][1], centers[1][1], logicalDistance);
        axis.setModulePitch(modulePitch.left);
        modulePitch.right = getAreaModulePitch(centers[1][0], centers[1][1], logicalDistance);

        axis.setModulePitch(modulePitch.top);
        baseLineX.setP1(axis.translate(-3,-3));

        axis.setModulePitch(modulePitch.left);
        baseLineY.setP1(axis.translate(-3,-3));

        axis.setOrigin(centers[0][1]);
        axis.setModulePitch(modulePitch.bottom);
        baseLineX.setP2(axis.translate(-6,0));

        axis.setOrigin(centers[1][0]);
        axis.setModulePitch(modulePitch.right);
        baseLineY.setP2(axis.translate(0,-6));
        }
        else if (ax == 1 && ay == 0) {
        axis.setOrigin(centers[1][0]);
        modulePitch.top = getAreaModulePitch(axis.translate(0,-3), centers[2][0], logicalDistance + 3);
        modulePitch.left = getAreaModulePitch(centers[1][0], centers[1][1], logicalDistance);
        axis.setModulePitch(modulePitch.top);
        modulePitch.bottom = getAreaModulePitch(centers[1][1], centers[2][1], logicalDistance);
        axis.setModulePitch(modulePitch.left);
        axis.setOrigin(centers[2][0]);
        modulePitch.right = getAreaModulePitch(axis.translate(-3,0), centers[2][1], logicalDistance + 3);

        axis.setOrigin(centers[1][0]);
        axis.setModulePitch(modulePitch.left);
        baseLineX.setP1(axis.translate(0,-6));

        baseLineY.setP1(axis.translate(0,-6));

        baseLineX.setP2(centers[1][1]);

        axis.setOrigin(centers[2][0]);
        axis.setModulePitch(modulePitch.right);
        baseLineY.setP2(axis.translate(3,-3));
        }
        else if (ax == 0 && ay == 1) {
        modulePitch.top = getAreaModulePitch(centers[0][1], centers[1][1], logicalDistance);
        axis.setOrigin(centers[0][2]);
        modulePitch.left = getAreaModulePitch(centers[0][1], axis.translate(3,0), logicalDistance + 3);
        axis.setModulePitch(modulePitch.top);
        modulePitch.bottom = getAreaModulePitch(axis.translate(0,-3), centers[1][2], logicalDistance + 3);
        axis.setModulePitch(modulePitch.bottom);
        modulePitch.right = getAreaModulePitch(centers[1][1], centers[1][2], logicalDistance);

        axis.setOrigin(centers[0][1]);
        axis.setModulePitch(modulePitch.top);
        baseLineX.setP1(axis.translate(-6,0));

        baseLineY.setP1(axis.translate(-6,0));

        axis.setOrigin(centers[0][2]);
        axis.setModulePitch(modulePitch.bottom);
        baseLineX.setP2(axis.translate(-3, 3));

        baseLineY.setP2(centers[1][1]);
        }
        else if (ax == 1 && ay == 1) {
        modulePitch.top = getAreaModulePitch(centers[1][1], centers[2][1], logicalDistance);
        modulePitch.left = getAreaModulePitch(centers[1][1], centers[1][2], logicalDistance);
        modulePitch.bottom = getAreaModulePitch(centers[1][2], centers[2][2], logicalDistance);
        modulePitch.right = getAreaModulePitch(centers[2][1], centers[2][2], logicalDistance);

        baseLineX.setP1(centers[1][1]);
        baseLineY.setP1(centers[1][1]);

        axis.setOrigin(centers[1][2]);
        axis.setModulePitch(modulePitch.left);
        baseLineX.setP2(axis.translate(0,6));

        axis.setOrigin(centers[2][1]);
        axis.setModulePitch(modulePitch.top);
        baseLineY.setP2(axis.translate(6,0));
        }

        samplingGrid.initGrid(ax,ay, sqrtNumAreaModules, sqrtNumAreaModules);

        for (int i = 0; i < sqrtNumAreaModules; i++) {
        gridLineX = new Line(baseLineX.getP1(), baseLineX.getP2());

        axis.setOrigin(gridLineX.getP1());
        axis.setModulePitch(modulePitch.top);
        gridLineX.setP1(axis.translate(i,0));

        axis.setOrigin(gridLineX.getP2());
        axis.setModulePitch(modulePitch.bottom);
        gridLineX.setP2(axis.translate(i,0));

        gridLineY = new Line(baseLineY.getP1(), baseLineY.getP2());

        axis.setOrigin(gridLineY.getP1());
        axis.setModulePitch(modulePitch.left);
        gridLineY.setP1(axis.translate(0,i));

        axis.setOrigin(gridLineY.getP2());
        axis.setModulePitch(modulePitch.right);
        gridLineY.setP2(axis.translate(0,i));

        samplingGrid.setXLine(ax,ay,i,gridLineX);
        samplingGrid.setYLine(ax,ay,i,gridLineY);

        }
        }
        }

        for (int ay = 0; ay < samplingGrid.getHeight(); ay++) {
        for (int ax = 0; ax < samplingGrid.getWidth();ax++) {
        canvas.drawLines(samplingGrid.getXLines(ax,ay), java.awt.Color.BLUE);
        canvas.drawLines(samplingGrid.getYLines(ax,ay), java.awt.Color.BLUE);
        }
        }

        return samplingGrid;
        }*/
        /// <summary> Generic Sampling grid method</summary>
        internal virtual SamplingGrid getSamplingGrid(FinderPattern finderPattern, AlignmentPattern alignmentPattern)
        {
            Point[][] centers = alignmentPattern.getCenter();

            int version = finderPattern.Version;
            int sqrtCenters = (version / 7) + 2;

            centers[0][0] = finderPattern.getCenter(FinderPattern.UL);
            centers[sqrtCenters - 1][0] = finderPattern.getCenter(FinderPattern.UR);
            centers[0][sqrtCenters - 1] = finderPattern.getCenter(FinderPattern.DL);
            //int sqrtNumModules = finderPattern.getSqrtNumModules(); /// The number of modules per one side is obtained
            int sqrtNumArea = sqrtCenters - 1;

            //--//--//--//--//--//--//--//--//--//--//--//--//--//--//--//--//--//--//--//--//--//--//--//--//--//--//--//--//--//--//
            SamplingGrid samplingGrid = new SamplingGrid(sqrtNumArea);

            Line baseLineX, baseLineY, gridLineX, gridLineY;

            ///???
            //Point[] targetCenters;

            //int logicalDistance = alignmentPattern.getLogicalDistance();
            Axis axis = new Axis(finderPattern.getAngle(), finderPattern.getModuleSize());
            ModulePitch modulePitch;

            // for each area :
            for (int ay = 0; ay < sqrtNumArea; ay++)
            {
                for (int ax = 0; ax < sqrtNumArea; ax++)
                {
                    modulePitch = new ModulePitch(this); /// Housing to order
                    baseLineX = new Line();
                    baseLineY = new Line();
                    axis.ModulePitch = finderPattern.getModuleSize();

                    Point[][] logicalCenters = AlignmentPattern.getLogicalCenter(finderPattern);

                    Point upperLeftPoint = centers[ax][ay];
                    Point upperRightPoint = centers[ax + 1][ay];
                    Point lowerLeftPoint = centers[ax][ay + 1];
                    Point lowerRightPoint = centers[ax + 1][ay + 1];

                    Point logicalUpperLeftPoint = logicalCenters[ax][ay];
                    Point logicalUpperRightPoint = logicalCenters[ax + 1][ay];
                    Point logicalLowerLeftPoint = logicalCenters[ax][ay + 1];
                    Point logicalLowerRightPoint = logicalCenters[ax + 1][ay + 1];

                    if (ax == 0 && ay == 0)
                    // left upper corner
                    {
                        if (sqrtNumArea == 1)
                        {
                            upperLeftPoint = axis.translate(upperLeftPoint, - 3, - 3);
                            upperRightPoint = axis.translate(upperRightPoint, 3, - 3);
                            lowerLeftPoint = axis.translate(lowerLeftPoint, - 3, 3);
                            lowerRightPoint = axis.translate(lowerRightPoint, 6, 6);

                            logicalUpperLeftPoint.translate(- 6, - 6);
                            logicalUpperRightPoint.translate(3, - 3);
                            logicalLowerLeftPoint.translate(- 3, 3);
                            logicalLowerRightPoint.translate(6, 6);
                        }
                        else
                        {
                            upperLeftPoint = axis.translate(upperLeftPoint, - 3, - 3);
                            upperRightPoint = axis.translate(upperRightPoint, 0, - 6);
                            lowerLeftPoint = axis.translate(lowerLeftPoint, - 6, 0);

                            logicalUpperLeftPoint.translate(- 6, - 6);
                            logicalUpperRightPoint.translate(0, - 6);
                            logicalLowerLeftPoint.translate(- 6, 0);
                        }
                    }
                    else if (ax == 0 && ay == sqrtNumArea - 1)
                    // left bottom corner
                    {
                        upperLeftPoint = axis.translate(upperLeftPoint, - 6, 0);
                        lowerLeftPoint = axis.translate(lowerLeftPoint, - 3, 3);
                        lowerRightPoint = axis.translate(lowerRightPoint, 0, 6);

                        logicalUpperLeftPoint.translate(- 6, 0);
                        logicalLowerLeftPoint.translate(- 6, 6);
                        logicalLowerRightPoint.translate(0, 6);
                    }
                    else if (ax == sqrtNumArea - 1 && ay == 0)
                    // right upper corner
                    {
                        upperLeftPoint = axis.translate(upperLeftPoint, 0, - 6);
                        upperRightPoint = axis.translate(upperRightPoint, 3, - 3);
                        lowerRightPoint = axis.translate(lowerRightPoint, 6, 0);

                        logicalUpperLeftPoint.translate(0, - 6);
                        logicalUpperRightPoint.translate(6, - 6);
                        logicalLowerRightPoint.translate(6, 0);
                    }
                    else if (ax == sqrtNumArea - 1 && ay == sqrtNumArea - 1)
                    // right bottom corner
                    {
                        lowerLeftPoint = axis.translate(lowerLeftPoint, 0, 6);
                        upperRightPoint = axis.translate(upperRightPoint, 6, 0);
                        lowerRightPoint = axis.translate(lowerRightPoint, 6, 6);

                        logicalLowerLeftPoint.translate(0, 6);
                        logicalUpperRightPoint.translate(6, 0);
                        logicalLowerRightPoint.translate(6, 6);
                    }
                    else if (ax == 0)
                    // left side
                    {
                        upperLeftPoint = axis.translate(upperLeftPoint, - 6, 0);
                        lowerLeftPoint = axis.translate(lowerLeftPoint, - 6, 0);

                        logicalUpperLeftPoint.translate(- 6, 0);
                        logicalLowerLeftPoint.translate(- 6, 0);
                    }
                    else if (ax == sqrtNumArea - 1)
                    // right
                    {
                        upperRightPoint = axis.translate(upperRightPoint, 6, 0);
                        lowerRightPoint = axis.translate(lowerRightPoint, 6, 0);

                        logicalUpperRightPoint.translate(6, 0);
                        logicalLowerRightPoint.translate(6, 0);
                    }
                    else if (ay == 0)
                    // top
                    {
                        upperLeftPoint = axis.translate(upperLeftPoint, 0, - 6);
                        upperRightPoint = axis.translate(upperRightPoint, 0, - 6);

                        logicalUpperLeftPoint.translate(0, - 6);
                        logicalUpperRightPoint.translate(0, - 6);
                    }
                    else if (ay == sqrtNumArea - 1)
                    // bottom
                    {
                        lowerLeftPoint = axis.translate(lowerLeftPoint, 0, 6);
                        lowerRightPoint = axis.translate(lowerRightPoint, 0, 6);

                        logicalLowerLeftPoint.translate(0, 6);
                        logicalLowerRightPoint.translate(0, 6);
                    }

                    if (ax == 0)
                    {
                        logicalUpperRightPoint.translate(1, 0);
                        logicalLowerRightPoint.translate(1, 0);
                    }
                    else
                    {
                        logicalUpperLeftPoint.translate(- 1, 0);
                        logicalLowerLeftPoint.translate(- 1, 0);
                    }

                    if (ay == 0)
                    {
                        logicalLowerLeftPoint.translate(0, 1);
                        logicalLowerRightPoint.translate(0, 1);
                    }
                    else
                    {
                        logicalUpperLeftPoint.translate(0, - 1);
                        logicalUpperRightPoint.translate(0, - 1);
                    }

                    int logicalWidth = logicalUpperRightPoint.X - logicalUpperLeftPoint.X;
                    int logicalHeight = logicalLowerLeftPoint.Y - logicalUpperLeftPoint.Y;

                    if (version < 7)
                    {
                        logicalWidth += 3;
                        logicalHeight += 3;
                    }
                    modulePitch.top = getAreaModulePitch(upperLeftPoint, upperRightPoint, logicalWidth - 1);
                    modulePitch.left = getAreaModulePitch(upperLeftPoint, lowerLeftPoint, logicalHeight - 1);
                    modulePitch.bottom = getAreaModulePitch(lowerLeftPoint, lowerRightPoint, logicalWidth - 1);
                    modulePitch.right = getAreaModulePitch(upperRightPoint, lowerRightPoint, logicalHeight - 1);

                    baseLineX.setP1(upperLeftPoint);
                    baseLineY.setP1(upperLeftPoint);
                    baseLineX.setP2(lowerLeftPoint);
                    baseLineY.setP2(upperRightPoint);

                    samplingGrid.initGrid(ax, ay, logicalWidth, logicalHeight);

                    for (int i = 0; i < logicalWidth; i++)
                    {
                        gridLineX = new Line(baseLineX.getP1(), baseLineX.getP2());

                        axis.Origin = gridLineX.getP1();
                        axis.ModulePitch = modulePitch.top;
                        gridLineX.setP1(axis.translate(i, 0));

                        axis.Origin = gridLineX.getP2();
                        axis.ModulePitch = modulePitch.bottom;
                        gridLineX.setP2(axis.translate(i, 0));

                        samplingGrid.setXLine(ax, ay, i, gridLineX);
                    }

                    for (int i = 0; i < logicalHeight; i++)
                    {

                        gridLineY = new Line(baseLineY.getP1(), baseLineY.getP2());

                        axis.Origin = gridLineY.getP1();
                        axis.ModulePitch = modulePitch.left;
                        gridLineY.setP1(axis.translate(0, i));

                        axis.Origin = gridLineY.getP2();
                        axis.ModulePitch = modulePitch.right;
                        gridLineY.setP2(axis.translate(0, i));

                        samplingGrid.setYLine(ax, ay, i, gridLineY);
                    }
                }
            }

            return samplingGrid;
        }
        public virtual QRCodeSymbol getQRCodeSymbol(int[][] image)
        {
            int longSide = (image.Length < image[0].Length)?image[0].Length:image.Length;
            QRCodeImageReader.DECIMAL_POINT = 23 - QRCodeUtility.sqrt(longSide / 256);
            bitmap = filterImage(image);
            canvas.println("Drawing matrix.");
            canvas.drawMatrix(bitmap);

            canvas.println("Scanning Finder Pattern.");
            FinderPattern finderPattern = null;
            try
            {
                finderPattern = FinderPattern.findFinderPattern(bitmap);
            }
            catch (FinderPatternNotFoundException e)
            {
                canvas.println("Not found, now retrying...");
                bitmap = applyCrossMaskingMedianFilter(bitmap, 5);
                canvas.drawMatrix(bitmap);
                for (int i = 0; i < 1000000000; i++)
                    ;
                try
                {
                    finderPattern = FinderPattern.findFinderPattern(bitmap);
                }
                catch (FinderPatternNotFoundException e2)
                {
                    throw new SymbolNotFoundException(e2.Message);
                }
                catch (VersionInformationException e2)
                {
                    throw new SymbolNotFoundException(e2.Message);
                }
            }
            catch (VersionInformationException e)
            {
                throw new SymbolNotFoundException(e.Message);
            }

            canvas.println("FinderPattern at");
            String finderPatternCoordinates = finderPattern.getCenter(FinderPattern.UL).ToString() + finderPattern.getCenter(FinderPattern.UR).ToString() + finderPattern.getCenter(FinderPattern.DL).ToString();
            canvas.println(finderPatternCoordinates);
            int[] sincos = finderPattern.getAngle();
            canvas.println("Angle*4098: Sin " + System.Convert.ToString(sincos[0]) + "  " + "Cos " + System.Convert.ToString(sincos[1]));

            int version = finderPattern.Version;
            canvas.println("Version: " + System.Convert.ToString(version));
            if (version < 1 || version > 40)
                throw new InvalidVersionException("Invalid version: " + version);

            AlignmentPattern alignmentPattern = null;
            try
            {
                alignmentPattern = AlignmentPattern.findAlignmentPattern(bitmap, finderPattern);
            }
            catch (AlignmentPatternNotFoundException e)
            {
                throw new SymbolNotFoundException(e.Message);
            }

            int matrixLength = alignmentPattern.getCenter().Length;
            canvas.println("AlignmentPatterns at");
            for (int y = 0; y < matrixLength; y++)
            {
                String alignmentPatternCoordinates = "";
                for (int x = 0; x < matrixLength; x++)
                {
                    alignmentPatternCoordinates += alignmentPattern.getCenter()[x][y].ToString();
                }
                canvas.println(alignmentPatternCoordinates);
            }
            //for(int i = 0; i < 500000; i++) Console.out.println("");

            canvas.println("Creating sampling grid.");
            //[TODO] need all-purpose method
            //samplingGrid = getSamplingGrid2_6(finderPattern, alignmentPattern);
            samplingGrid = getSamplingGrid(finderPattern, alignmentPattern);
            canvas.println("Reading grid.");
            bool[][] qRCodeMatrix = null;
            try
            {
                qRCodeMatrix = getQRCodeMatrix(bitmap, samplingGrid);
            }
            catch (System.IndexOutOfRangeException e)
            {
                throw new SymbolNotFoundException("Sampling grid exceeded image boundary");
            }
            //canvas.drawMatrix(qRCodeMatrix);
            return new QRCodeSymbol(qRCodeMatrix);
        }
示例#3
0
			public AreaGrid(SamplingGrid enclosingInstance, int width, int height)
			{
				InitBlock(enclosingInstance);
				xLine = new Line[width];
				yLine = new Line[height];
			}
        //gridLines[areaX][areaY][direction(x=0,y=1)][EachLines]
        internal virtual bool[][] getQRCodeMatrix(bool[][] image, SamplingGrid gridLines)
        {
            //int gridSize = gridLines.getWidth() * gridLines.getWidth(0,0);
            int gridSize = gridLines.TotalWidth;

            // now this is done within the SamplingGrid class...
            //		if (gridLines.getWidth() >= 2)
            //			gridSize-=1;

            canvas.println("gridSize=" + gridSize);
            //canvas.println("gridLines.getWidth() * gridLines.getWidth(0,0) = "+gridLines.getWidth() * gridLines.getWidth(0,0));
            Point bottomRightPoint = null;
            bool[][] sampledMatrix = new bool[gridSize][];
            for (int i = 0; i < gridSize; i++)
            {
                sampledMatrix[i] = new bool[gridSize];
            }
            for (int ay = 0; ay < gridLines.getHeight(); ay++)
            {
                for (int ax = 0; ax < gridLines.getWidth(); ax++)
                {
                    System.Collections.ArrayList sampledPoints = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); //only for visualiz;
                    for (int y = 0; y < gridLines.getHeight(ax, ay); y++)
                    {
                        for (int x = 0; x < gridLines.getWidth(ax, ay); x++)
                        {
                            int x1 = gridLines.getXLine(ax, ay, x).getP1().X;
                            int y1 = gridLines.getXLine(ax, ay, x).getP1().Y;
                            int x2 = gridLines.getXLine(ax, ay, x).getP2().X;
                            int y2 = gridLines.getXLine(ax, ay, x).getP2().Y;
                            int x3 = gridLines.getYLine(ax, ay, y).getP1().X;
                            int y3 = gridLines.getYLine(ax, ay, y).getP1().Y;
                            int x4 = gridLines.getYLine(ax, ay, y).getP2().X;
                            int y4 = gridLines.getYLine(ax, ay, y).getP2().Y;

                            int e = (y2 - y1) * (x3 - x4) - (y4 - y3) * (x1 - x2);
                            int f = (x1 * y2 - x2 * y1) * (x3 - x4) - (x3 * y4 - x4 * y3) * (x1 - x2);
                            int g = (x3 * y4 - x4 * y3) * (y2 - y1) - (x1 * y2 - x2 * y1) * (y4 - y3);
                            sampledMatrix[gridLines.getX(ax, x)][gridLines.getY(ay, y)] = image[f / e][g / e];
                            if ((ay == gridLines.getHeight() - 1 && ax == gridLines.getWidth() - 1) && y == gridLines.getHeight(ax, ay) - 1 && x == gridLines.getWidth(ax, ay) - 1)
                                bottomRightPoint = new Point(f / e, g / e);
                            //calling canvas.drawPoint in loop can be very slow.
                            // use canvas.drawPoints if you need
                            //canvas.drawPoint(new Point(f / e,g / e), Color.RED);
                        }
                    }
                }
            }
            if (bottomRightPoint.X > image.Length - 1 || bottomRightPoint.Y > image[0].Length - 1)
                throw new System.IndexOutOfRangeException("Sampling grid pointed out of image");
            canvas.drawPoint(bottomRightPoint, MessagingToolkit.QRCode.Codec.Util.Color_Fields.BLUE);

            return sampledMatrix;
        }
示例#5
0
			private void  InitBlock(SamplingGrid enclosingInstance)
			{
				this.enclosingInstance = enclosingInstance;
			}