Example #1
0
        private static void DrawModeMessage(AztecCode matrix, bool compact, int matrixSize, BitList modeMessage)
        {
            int center = matrixSize / 2;

            if (compact)
            {
                for (int i = 0; i < 7; i++)
                {
                    int offset = center - 3 + i;
                    if (modeMessage.GetBit(i))
                    {
                        matrix.Set(offset, center - 5);
                    }

                    if (modeMessage.GetBit(i + 7))
                    {
                        matrix.Set(center + 5, offset);
                    }

                    if (modeMessage.GetBit(20 - i))
                    {
                        matrix.Set(offset, center + 5);
                    }

                    if (modeMessage.GetBit(27 - i))
                    {
                        matrix.Set(center - 5, offset);
                    }
                }
            }
            else
            {
                for (int i = 0; i < 10; i++)
                {
                    int offset = center - 5 + i + i / 5;
                    if (modeMessage.GetBit(i))
                    {
                        matrix.Set(offset, center - 7);
                    }

                    if (modeMessage.GetBit(i + 10))
                    {
                        matrix.Set(center + 7, offset);
                    }

                    if (modeMessage.GetBit(29 - i))
                    {
                        matrix.Set(offset, center + 7);
                    }

                    if (modeMessage.GetBit(39 - i))
                    {
                        matrix.Set(center - 7, offset);
                    }
                }
            }
        }
Example #2
0
        private static void DrawBullsEye(AztecCode matrix, int center, int size)
        {
            for (int i = 0; i < size; i += 2)
            {
                for (int j = center - i; j <= center + i; j++)
                {
                    matrix.Set(j, center - i);
                    matrix.Set(j, center + i);
                    matrix.Set(center - i, j);
                    matrix.Set(center + i, j);
                }
            }

            matrix.Set(center - size, center - size);
            matrix.Set(center - size + 1, center - size);
            matrix.Set(center - size, center - size + 1);
            matrix.Set(center + size, center - size);
            matrix.Set(center + size, center - size + 1);
            matrix.Set(center + size, center + size - 1);
        }
Example #3
0
        public static IBarcode Encode(string content, int minimumEccPercentage = 23, int userSpecifiedLayers = 0)
        {
            BitList bits    = HighLevelEncoding.Encode(content.Select(x => (byte)x).ToArray());
            int     eccBits = ((bits.Length * minimumEccPercentage) / 100) + 11;

            int     totalSizeBits = bits.Length + eccBits;
            int     layers, totalBitsInLayer, wordSize;
            bool    compact;
            BitList stuffedBits;

            if (userSpecifiedLayers != 0)
            {
                compact = userSpecifiedLayers < 0;
                layers  = compact ? -userSpecifiedLayers : userSpecifiedLayers;

                if ((compact && layers > MaximumNumberOfCompactBits) || (!compact && layers > MaximumNumberOfBits))
                {
                    throw new InvalidOperationException($"Illegal value {userSpecifiedLayers} for layers");
                }

                totalBitsInLayer = GetTotalBitsInLayer(layers, compact);
                wordSize         = WordSize[layers];
                int usableBitsInLayer = totalBitsInLayer - (totalBitsInLayer % wordSize);
                stuffedBits = StuffBits(bits, wordSize);

                if (stuffedBits.Length + eccBits > usableBitsInLayer)
                {
                    throw new InvalidOperationException("Data too large for user specified layer");
                }

                if (compact && stuffedBits.Length > wordSize * 64)
                {
                    throw new InvalidOperationException("Data too large for user specified layer");
                }
            }
            else
            {
                stuffedBits = new BitList();
                wordSize    = 0;

                // We look at the possible table sizes in the order Compact1, Compact2, Compact3,
                // Compact4, Normal4,...  Normal(i) for i < 4 isn't typically used since Compact(i+1)
                // is the same size, but has more data.
                for (int i = 0; ; i++)
                {
                    if (i > MaximumNumberOfBits)
                    {
                        throw new InvalidOperationException("Data too large for an aztec code");
                    }

                    compact = i <= 3;
                    layers  = compact ? i + 1 : i;

                    totalBitsInLayer = GetTotalBitsInLayer(layers, compact);
                    if (totalSizeBits > totalBitsInLayer)
                    {
                        continue;
                    }

                    // [Re]stuff the bits if this is the first opportunity, or if the
                    // wordSize has changed
                    if (wordSize != WordSize[layers])
                    {
                        wordSize    = WordSize[layers];
                        stuffedBits = StuffBits(bits, wordSize);
                    }

                    int usableBitsInLayers = totalBitsInLayer - (totalBitsInLayer % wordSize);

                    if (compact && stuffedBits.Length > wordSize * 64)
                    {
                        continue; // Compact format only allows 64 data words, though C4 can hold more words than that
                    }
                    if (stuffedBits.Length + eccBits <= usableBitsInLayers)
                    {
                        break;
                    }
                }
            }
            BitList messageBits        = ErrorCorrection.GenerateCheckWords(stuffedBits, totalBitsInLayer, wordSize);
            int     messageSizeInWords = stuffedBits.Length / wordSize;
            BitList modeMessage        = GenerateModeMessage(compact, layers, messageSizeInWords);

            // allocate symbol
            int baseMatrixSize = compact
                ? 11 + layers * 4
                : 14 + layers * 4;
            var alignmentMap = new int[baseMatrixSize];
            int matrixSize;

            if (compact)
            {
                // no alignment marks in compact mode, alignmentMap is a no-op
                matrixSize = baseMatrixSize;
                for (int i = 0; i < alignmentMap.Length; i++)
                {
                    alignmentMap[i] = i;
                }
            }
            else
            {
                matrixSize = baseMatrixSize + 1 + 2 * ((baseMatrixSize / 2 - 1) / 15);
                int origCenter = baseMatrixSize / 2;
                int center     = matrixSize / 2;
                for (int i = 0; i < origCenter; i++)
                {
                    int newOffset = i + i / 15;
                    alignmentMap[origCenter - i - 1] = center - newOffset - 1;
                    alignmentMap[origCenter + i]     = center + newOffset + 1;
                }
            }
            var code = new AztecCode(matrixSize);

            code.Content = content;

            // draw data bits
            for (int i = 0, rowOffset = 0; i < layers; i++)
            {
                int rowSize = (layers - i) * 4;
                if (compact)
                {
                    rowSize += 9;
                }
                else
                {
                    rowSize += 12;
                }

                for (int j = 0; j < rowSize; j++)
                {
                    int columnOffset = j * 2;
                    for (int k = 0; k < 2; k++)
                    {
                        if (messageBits.GetBit(rowOffset + columnOffset + k))
                        {
                            code.Set(alignmentMap[i * 2 + k], alignmentMap[i * 2 + j]);
                        }

                        if (messageBits.GetBit(rowOffset + rowSize * 2 + columnOffset + k))
                        {
                            code.Set(alignmentMap[i * 2 + j], alignmentMap[baseMatrixSize - 1 - i * 2 - k]);
                        }

                        if (messageBits.GetBit(rowOffset + rowSize * 4 + columnOffset + k))
                        {
                            code.Set(alignmentMap[baseMatrixSize - 1 - i * 2 - k], alignmentMap[baseMatrixSize - 1 - i * 2 - j]);
                        }

                        if (messageBits.GetBit(rowOffset + rowSize * 6 + columnOffset + k))
                        {
                            code.Set(alignmentMap[baseMatrixSize - 1 - i * 2 - j], alignmentMap[i * 2 + k]);
                        }
                    }
                }

                rowOffset += rowSize * 8;
            }

            // draw mode message
            DrawModeMessage(code, compact, matrixSize, modeMessage);

            // draw alignment marks
            if (compact)
            {
                DrawBullsEye(code, matrixSize / 2, 5);
            }
            else
            {
                DrawBullsEye(code, matrixSize / 2, 7);
                for (int i = 0, j = 0; i < baseMatrixSize / 2 - 1; i += 15, j += 16)
                {
                    for (int k = (matrixSize / 2) & 1; k < matrixSize; k += 2)
                    {
                        code.Set(matrixSize / 2 - j, k);
                        code.Set(matrixSize / 2 + j, k);
                        code.Set(k, matrixSize / 2 - j);
                        code.Set(k, matrixSize / 2 + j);
                    }
                }
            }

            return(code);
        }