| public set_Renamed ( int x, int y, int value_Renamed ) : void | ||
| x | int | |
| y | int | |
| value_Renamed | int | |
| return | void | |
// Note that we cannot unify the function with embedPositionDetectionPattern() despite they are
// almost identical, since we cannot write a function that takes 2D arrays in different sizes in
// C/C++. We should live with the fact.
private static void embedPositionAdjustmentPattern(int xStart, int yStart, ByteMatrix matrix)
{
// We know the width and height.
if (POSITION_ADJUSTMENT_PATTERN[0].Length != 5 || POSITION_ADJUSTMENT_PATTERN.Length != 5)
{
throw new WriterException("Bad position adjustment");
}
for (int y = 0; y < 5; ++y)
{
for (int x = 0; x < 5; ++x)
{
if (!isEmpty(matrix.get_Renamed(xStart + x, yStart + y)))
{
throw new WriterException();
}
matrix.set_Renamed(xStart + x, yStart + y, POSITION_ADJUSTMENT_PATTERN[y][x]);
}
}
}
private static void embedPositionDetectionPattern(int xStart, int yStart, ByteMatrix matrix)
{
// We know the width and height.
if (POSITION_DETECTION_PATTERN[0].Length != 7 || POSITION_DETECTION_PATTERN.Length != 7)
{
throw new WriterException("Bad position detection pattern");
}
for (int y = 0; y < 7; ++y)
{
for (int x = 0; x < 7; ++x)
{
if (!isEmpty(matrix.get_Renamed(xStart + x, yStart + y)))
{
throw new WriterException();
}
matrix.set_Renamed(xStart + x, yStart + y, POSITION_DETECTION_PATTERN[y][x]);
}
}
}
private static void embedHorizontalSeparationPattern(int xStart, int yStart, ByteMatrix matrix)
{
// We know the width and height.
if (HORIZONTAL_SEPARATION_PATTERN[0].Length != 8 || HORIZONTAL_SEPARATION_PATTERN.Length != 1)
{
throw new WriterException("Bad horizontal separation pattern");
}
for (int x = 0; x < 8; ++x)
{
if (!isEmpty(matrix.get_Renamed(xStart + x, yStart)))
{
throw new WriterException();
}
matrix.set_Renamed(xStart + x, yStart, HORIZONTAL_SEPARATION_PATTERN[0][x]);
}
}
private static void embedVerticalSeparationPattern(int xStart, int yStart, ByteMatrix matrix)
{
// We know the width and height.
if (VERTICAL_SEPARATION_PATTERN[0].Length != 1 || VERTICAL_SEPARATION_PATTERN.Length != 7)
{
throw new WriterException("Bad vertical separation pattern");
}
for (int y = 0; y < 7; ++y)
{
if (!isEmpty(matrix.get_Renamed(xStart, yStart + y)))
{
throw new WriterException();
}
matrix.set_Renamed(xStart, yStart + y, VERTICAL_SEPARATION_PATTERN[y][0]);
}
}
// Embed the lonely dark dot at left bottom corner. JISX0510:2004 (p.46)
private static void embedDarkDotAtLeftBottomCorner(ByteMatrix matrix)
{
if (matrix.get_Renamed(8, matrix.Height - 8) == 0)
{
throw new WriterException();
}
matrix.set_Renamed(8, matrix.Height - 8, 1);
}
private static void embedTimingPatterns(ByteMatrix matrix)
{
// -8 is for skipping position detection patterns (size 7), and two horizontal/vertical
// separation patterns (size 1). Thus, 8 = 7 + 1.
for (int i = 8; i < matrix.Width - 8; ++i)
{
int bit = (i + 1)%2;
// Horizontal line.
if (!isValidValue(matrix.get_Renamed(i, 6)))
{
throw new WriterException();
}
if (isEmpty(matrix.get_Renamed(i, 6)))
{
matrix.set_Renamed(i, 6, bit);
}
// Vertical line.
if (!isValidValue(matrix.get_Renamed(6, i)))
{
throw new WriterException();
}
if (isEmpty(matrix.get_Renamed(6, i)))
{
matrix.set_Renamed(6, i, bit);
}
}
}
// Embed "dataBits" using "getMaskPattern". On success, modify the matrix and return true.
// For debugging purposes, it skips masking process if "getMaskPattern" is -1.
// See 8.7 of JISX0510:2004 (p.38) for how to embed data bits.
public static void embedDataBits(BitVector dataBits, int maskPattern, ByteMatrix matrix)
{
int bitIndex = 0;
int direction = - 1;
// Start from the right bottom cell.
int x = matrix.Width - 1;
int y = matrix.Height - 1;
while (x > 0)
{
// Skip the vertical timing pattern.
if (x == 6)
{
x -= 1;
}
while (y >= 0 && y < matrix.Height)
{
for (int i = 0; i < 2; ++i)
{
int xx = x - i;
// Skip the cell if it's not empty.
if (!isEmpty(matrix.get_Renamed(xx, y)))
{
continue;
}
int bit;
if (bitIndex < dataBits.size())
{
bit = dataBits.at(bitIndex);
++bitIndex;
}
else
{
// Padding bit. If there is no bit left, we'll fill the left cells with 0, as described
// in 8.4.9 of JISX0510:2004 (p. 24).
bit = 0;
}
// Skip masking if mask_pattern is -1.
if (maskPattern != - 1)
{
if (MaskUtil.getDataMaskBit(maskPattern, xx, y))
{
bit ^= 0x1;
}
}
matrix.set_Renamed(xx, y, bit);
}
y += direction;
}
direction = - direction; // Reverse the direction.
y += direction;
x -= 2; // Move to the left.
}
// All bits should be consumed.
if (bitIndex != dataBits.size())
{
throw new WriterException("Not all bits consumed: " + bitIndex + '/' + dataBits.size());
}
}
// Embed version information if need be. On success, modify the matrix and return true.
// See 8.10 of JISX0510:2004 (p.47) for how to embed version information.
public static void maybeEmbedVersionInfo(int version, ByteMatrix matrix)
{
if (version < 7)
{
// Version info is necessary if version >= 7.
return; // Don't need version info.
}
var versionInfoBits = new BitVector();
makeVersionInfoBits(version, versionInfoBits);
int bitIndex = 6*3 - 1; // It will decrease from 17 to 0.
for (int i = 0; i < 6; ++i)
{
for (int j = 0; j < 3; ++j)
{
// Place bits in LSB (least significant bit) to MSB order.
int bit = versionInfoBits.at(bitIndex);
bitIndex--;
// Left bottom corner.
matrix.set_Renamed(i, matrix.Height - 11 + j, bit);
// Right bottom corner.
matrix.set_Renamed(matrix.Height - 11 + j, i, bit);
}
}
}
// Embed type information. On success, modify the matrix.
public static void embedTypeInfo(ErrorCorrectionLevel ecLevel, int maskPattern, ByteMatrix matrix)
{
var typeInfoBits = new BitVector();
makeTypeInfoBits(ecLevel, maskPattern, typeInfoBits);
for (int i = 0; i < typeInfoBits.size(); ++i)
{
// Place bits in LSB to MSB order. LSB (least significant bit) is the last value in
// "typeInfoBits".
int bit = typeInfoBits.at(typeInfoBits.size() - 1 - i);
// Type info bits at the left top corner. See 8.9 of JISX0510:2004 (p.46).
int x1 = TYPE_INFO_COORDINATES[i][0];
int y1 = TYPE_INFO_COORDINATES[i][1];
matrix.set_Renamed(x1, y1, bit);
if (i < 8)
{
// Right top corner.
int x2 = matrix.Width - i - 1;
int y2 = 8;
matrix.set_Renamed(x2, y2, bit);
}
else
{
// Left bottom corner.
int x2 = 8;
int y2 = matrix.Height - 7 + (i - 8);
matrix.set_Renamed(x2, y2, bit);
}
}
}