zxing_cpp_no_cmake 0.1.1

data/ext/zxing/zxing-cpp/core/src/zxing/datamatrix/Version.cpp

@@ -0,0 +1,199 @@
+/*
+ *  Version.cpp
+ *  zxing
+ *
+ *  Created by Luiz Silva on 09/02/2010.
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zxing/datamatrix/Version.h>
+#include <limits>
+#include <iostream>
+
+namespace zxing {
+namespace datamatrix {
+using namespace std;
+
+ECB::ECB(int count, int dataCodewords) :
+    count_(count), dataCodewords_(dataCodewords) {
+}
+
+int ECB::getCount() {
+  return count_;
+}
+
+int ECB::getDataCodewords() {
+  return dataCodewords_;
+}
+
+ECBlocks::ECBlocks(int ecCodewords, ECB *ecBlocks) :
+    ecCodewords_(ecCodewords), ecBlocks_(1, ecBlocks) {
+}
+
+ECBlocks::ECBlocks(int ecCodewords, ECB *ecBlocks1, ECB *ecBlocks2) :
+    ecCodewords_(ecCodewords), ecBlocks_(1, ecBlocks1) {
+  ecBlocks_.push_back(ecBlocks2);
+}
+
+int ECBlocks::getECCodewords() {
+  return ecCodewords_;
+}
+
+std::vector<ECB*>& ECBlocks::getECBlocks() {
+  return ecBlocks_;
+}
+
+ECBlocks::~ECBlocks() {
+  for (size_t i = 0; i < ecBlocks_.size(); i++) {
+    delete ecBlocks_[i];
+  }
+}
+
+vector<Ref<Version> > Version::VERSIONS;
+static int N_VERSIONS = Version::buildVersions();
+
+Version::Version(int versionNumber, int symbolSizeRows, int symbolSizeColumns, int dataRegionSizeRows,
+		int dataRegionSizeColumns, ECBlocks* ecBlocks) : versionNumber_(versionNumber), 
+		symbolSizeRows_(symbolSizeRows), symbolSizeColumns_(symbolSizeColumns), 
+		dataRegionSizeRows_(dataRegionSizeRows), dataRegionSizeColumns_(dataRegionSizeColumns), 
+		ecBlocks_(ecBlocks), totalCodewords_(0) {
+    // Calculate the total number of codewords
+    int total = 0;
+    int ecCodewords = ecBlocks_->getECCodewords();
+    vector<ECB*> &ecbArray = ecBlocks_->getECBlocks();
+    for (unsigned int i = 0; i < ecbArray.size(); i++) {
+      ECB *ecBlock = ecbArray[i];
+      total += ecBlock->getCount() * (ecBlock->getDataCodewords() + ecCodewords);
+    }
+    totalCodewords_ = total;
+}
+
+Version::~Version() {
+    delete ecBlocks_;
+}
+
+int Version::getVersionNumber() {
+  return versionNumber_;
+}
+
+int Version::getSymbolSizeRows() {
+  return symbolSizeRows_;
+}
+  
+int Version::getSymbolSizeColumns() {
+  return symbolSizeColumns_;
+}
+
+int Version::getDataRegionSizeRows() {
+  return dataRegionSizeRows_;
+}
+  
+int Version::getDataRegionSizeColumns() {
+  return dataRegionSizeColumns_;
+}
+  
+int Version::getTotalCodewords() {
+  return totalCodewords_;
+}
+
+ECBlocks* Version::getECBlocks() {
+  return ecBlocks_;
+}
+  
+Ref<Version> Version::getVersionForDimensions(int numRows, int numColumns) {
+    if ((numRows & 0x01) != 0 || (numColumns & 0x01) != 0) {
+      throw ReaderException("Number of rows and columns must be even");
+    }
+    
+    // TODO(bbrown): This is doing a linear search through the array of versions.
+    // If we interleave the rectangular versions with the square versions we could
+    // do a binary search.
+    for (int i = 0; i < N_VERSIONS; ++i){
+      Ref<Version> version(VERSIONS[i]);
+      if (version->getSymbolSizeRows() == numRows && version->getSymbolSizeColumns() == numColumns) {
+        return version;
+      }
+    }
+    throw ReaderException("Error version not found");
+  }
+
+/**
+ * See ISO 16022:2006 5.5.1 Table 7
+ */
+int Version::buildVersions() {
+  VERSIONS.push_back(Ref<Version>(new Version(1, 10, 10, 8, 8,
+            					  new ECBlocks(5, new ECB(1, 3)))));
+  VERSIONS.push_back(Ref<Version>(new Version(2, 12, 12, 10, 10,
+            					  new ECBlocks(7, new ECB(1, 5)))));
+  VERSIONS.push_back(Ref<Version>(new Version(3, 14, 14, 12, 12,
+            					  new ECBlocks(10, new ECB(1, 8)))));
+  VERSIONS.push_back(Ref<Version>(new Version(4, 16, 16, 14, 14,
+            					  new ECBlocks(12, new ECB(1, 12)))));
+  VERSIONS.push_back(Ref<Version>(new Version(5, 18, 18, 16, 16,
+            					  new ECBlocks(14, new ECB(1, 18)))));
+  VERSIONS.push_back(Ref<Version>(new Version(6, 20, 20, 18, 18,
+            					  new ECBlocks(18, new ECB(1, 22)))));
+  VERSIONS.push_back(Ref<Version>(new Version(7, 22, 22, 20, 20,
+            					  new ECBlocks(20, new ECB(1, 30)))));
+  VERSIONS.push_back(Ref<Version>(new Version(8, 24, 24, 22, 22,
+            					  new ECBlocks(24, new ECB(1, 36)))));
+  VERSIONS.push_back(Ref<Version>(new Version(9, 26, 26, 24, 24,
+            					  new ECBlocks(28, new ECB(1, 44)))));
+  VERSIONS.push_back(Ref<Version>(new Version(10, 32, 32, 14, 14,
+            					  new ECBlocks(36, new ECB(1, 62)))));
+  VERSIONS.push_back(Ref<Version>(new Version(11, 36, 36, 16, 16,
+            					  new ECBlocks(42, new ECB(1, 86)))));
+  VERSIONS.push_back(Ref<Version>(new Version(12, 40, 40, 18, 18,
+            					  new ECBlocks(48, new ECB(1, 114)))));
+  VERSIONS.push_back(Ref<Version>(new Version(13, 44, 44, 20, 20,
+            					  new ECBlocks(56, new ECB(1, 144)))));
+  VERSIONS.push_back(Ref<Version>(new Version(14, 48, 48, 22, 22,
+            					  new ECBlocks(68, new ECB(1, 174)))));
+  VERSIONS.push_back(Ref<Version>(new Version(15, 52, 52, 24, 24,
+            					  new ECBlocks(42, new ECB(2, 102)))));
+  VERSIONS.push_back(Ref<Version>(new Version(16, 64, 64, 14, 14,
+            					  new ECBlocks(56, new ECB(2, 140)))));
+  VERSIONS.push_back(Ref<Version>(new Version(17, 72, 72, 16, 16,
+            					  new ECBlocks(36, new ECB(4, 92)))));
+  VERSIONS.push_back(Ref<Version>(new  Version(18, 80, 80, 18, 18,
+            					  new ECBlocks(48, new ECB(4, 114)))));
+  VERSIONS.push_back(Ref<Version>(new Version(19, 88, 88, 20, 20,
+            					  new ECBlocks(56, new ECB(4, 144)))));
+  VERSIONS.push_back(Ref<Version>(new Version(20, 96, 96, 22, 22,
+            					  new ECBlocks(68, new ECB(4, 174)))));
+  VERSIONS.push_back(Ref<Version>(new Version(21, 104, 104, 24, 24,
+            					  new ECBlocks(56, new ECB(6, 136)))));
+  VERSIONS.push_back(Ref<Version>(new Version(22, 120, 120, 18, 18,
+            					  new ECBlocks(68, new ECB(6, 175)))));
+  VERSIONS.push_back(Ref<Version>(new Version(23, 132, 132, 20, 20,
+            					  new ECBlocks(62, new ECB(8, 163)))));
+  VERSIONS.push_back(Ref<Version>(new Version(24, 144, 144, 22, 22,
+            					  new ECBlocks(62, new ECB(8, 156), new ECB(2, 155)))));
+  VERSIONS.push_back(Ref<Version>(new Version(25, 8, 18, 6, 16,
+            					  new ECBlocks(7, new ECB(1, 5)))));
+  VERSIONS.push_back(Ref<Version>(new Version(26, 8, 32, 6, 14,
+            					  new ECBlocks(11, new ECB(1, 10)))));
+  VERSIONS.push_back(Ref<Version>(new Version(27, 12, 26, 10, 24,
+					              new ECBlocks(14, new ECB(1, 16)))));
+  VERSIONS.push_back(Ref<Version>(new Version(28, 12, 36, 10, 16,
+					              new ECBlocks(18, new ECB(1, 22)))));
+  VERSIONS.push_back(Ref<Version>(new Version(29, 16, 36, 14, 16,
+					              new ECBlocks(24, new ECB(1, 32)))));
+  VERSIONS.push_back(Ref<Version>(new Version(30, 16, 48, 14, 22,
+					              new ECBlocks(28, new ECB(1, 49)))));
+  return VERSIONS.size();
+}
+}
+}

data/ext/zxing/zxing-cpp/core/src/zxing/datamatrix/Version.h

@@ -0,0 +1,87 @@
+#ifndef __VERSION_H__
+#define __VERSION_H__
+
+/*
+ *  Version.h
+ *  zxing
+ *
+ *  Created by Luiz Silva on 09/02/2010.
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zxing/ReaderException.h>
+#include <zxing/common/BitMatrix.h>
+#include <zxing/common/Counted.h>
+#include <vector>
+
+namespace zxing {
+namespace datamatrix {
+
+class ECB {
+private:
+  int count_;
+  int dataCodewords_;
+public:
+  ECB(int count, int dataCodewords);
+  int getCount();
+  int getDataCodewords();
+};
+
+class ECBlocks {
+private:
+  int ecCodewords_;
+  std::vector<ECB*> ecBlocks_;
+public:
+  ECBlocks(int ecCodewords, ECB *ecBlocks);
+  ECBlocks(int ecCodewords, ECB *ecBlocks1, ECB *ecBlocks2);
+  int getECCodewords();
+  std::vector<ECB*>& getECBlocks();
+  ~ECBlocks();
+};
+
+class Version : public Counted {
+private:
+  int versionNumber_;
+  int symbolSizeRows_;
+  int symbolSizeColumns_;
+  int dataRegionSizeRows_;
+  int dataRegionSizeColumns_;
+  ECBlocks* ecBlocks_;
+  int totalCodewords_;
+  Version(int versionNumber, int symbolSizeRows, int symbolSizeColumns, int dataRegionSizeRows,
+		  int dataRegionSizeColumns, ECBlocks *ecBlocks);
+
+public:
+  static std::vector<Ref<Version> > VERSIONS;
+  
+  ~Version();
+  int getVersionNumber();
+  int getSymbolSizeRows();
+  int getSymbolSizeColumns();  
+  int getDataRegionSizeRows();  
+  int getDataRegionSizeColumns();
+  int getTotalCodewords();
+  ECBlocks* getECBlocks();
+  static int  buildVersions();  
+  Ref<Version> getVersionForDimensions(int numRows, int numColumns);
+  
+private:
+  Version(const Version&);
+  Version & operator=(const Version&);
+};
+}
+}
+
+#endif // __VERSION_H__

data/ext/zxing/zxing-cpp/core/src/zxing/datamatrix/decoder/BitMatrixParser.cpp

@@ -0,0 +1,361 @@
+/*
+ *  BitMatrixParser.cpp
+ *  zxing
+ *
+ *  Created by Luiz Silva on 09/02/2010.
+ *  Copyright 2010 ZXing authors All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <zxing/datamatrix/decoder/BitMatrixParser.h>
+#include <zxing/common/IllegalArgumentException.h>
+
+#include <iostream>
+
+namespace zxing {
+namespace datamatrix {
+
+int BitMatrixParser::copyBit(size_t x, size_t y, int versionBits) {
+  return bitMatrix_->get(x, y) ? (versionBits << 1) | 0x1 : versionBits << 1;
+}
+
+BitMatrixParser::BitMatrixParser(Ref<BitMatrix> bitMatrix) : bitMatrix_(NULL),
+                                                             parsedVersion_(NULL),
+                                                             readBitMatrix_(NULL) {
+  size_t dimension = bitMatrix->getHeight();
+  if (dimension < 8 || dimension > 144 || (dimension & 0x01) != 0)
+    throw ReaderException("Dimension must be even, > 8 < 144");
+
+  parsedVersion_ = readVersion(bitMatrix);
+  bitMatrix_ = extractDataRegion(bitMatrix);
+  readBitMatrix_ = new BitMatrix(bitMatrix_->getWidth(), bitMatrix_->getHeight());
+}
+
+Ref<Version> BitMatrixParser::readVersion(Ref<BitMatrix> bitMatrix) {
+  if (parsedVersion_ != 0) {
+    return parsedVersion_;
+  }
+
+  int numRows = bitMatrix->getHeight();
+  int numColumns = bitMatrix->getWidth();
+
+  Ref<Version> version = parsedVersion_->getVersionForDimensions(numRows, numColumns);
+  if (version != 0) {
+    return version;
+  }
+  throw ReaderException("Couldn't decode version");
+}
+
+ArrayRef<char> BitMatrixParser::readCodewords() {
+    ArrayRef<char> result(parsedVersion_->getTotalCodewords());
+    int resultOffset = 0;
+    int row = 4;
+    int column = 0;
+
+    int numRows = bitMatrix_->getHeight();
+    int numColumns = bitMatrix_->getWidth();
+
+    bool corner1Read = false;
+    bool corner2Read = false;
+    bool corner3Read = false;
+    bool corner4Read = false;
+
+    // Read all of the codewords
+    do {
+      // Check the four corner cases
+      if ((row == numRows) && (column == 0) && !corner1Read) {
+        result[resultOffset++] = (char) readCorner1(numRows, numColumns);
+        row -= 2;
+        column +=2;
+        corner1Read = true;
+      } else if ((row == numRows-2) && (column == 0) && ((numColumns & 0x03) != 0) && !corner2Read) {
+        result[resultOffset++] = (char) readCorner2(numRows, numColumns);
+        row -= 2;
+        column +=2;
+        corner2Read = true;
+      } else if ((row == numRows+4) && (column == 2) && ((numColumns & 0x07) == 0) && !corner3Read) {
+        result[resultOffset++] = (char) readCorner3(numRows, numColumns);
+        row -= 2;
+        column +=2;
+        corner3Read = true;
+      } else if ((row == numRows-2) && (column == 0) && ((numColumns & 0x07) == 4) && !corner4Read) {
+        result[resultOffset++] = (char) readCorner4(numRows, numColumns);
+        row -= 2;
+        column +=2;
+        corner4Read = true;
+      } else {
+        // Sweep upward diagonally to the right
+        do {
+          if ((row < numRows) && (column >= 0) && !readBitMatrix_->get(column, row)) {
+            result[resultOffset++] = (char) readUtah(row, column, numRows, numColumns);
+          }
+          row -= 2;
+          column +=2;
+        } while ((row >= 0) && (column < numColumns));
+        row += 1;
+        column +=3;
+
+        // Sweep downward diagonally to the left
+        do {
+          if ((row >= 0) && (column < numColumns) && !readBitMatrix_->get(column, row)) {
+             result[resultOffset++] = (char) readUtah(row, column, numRows, numColumns);
+          }
+          row += 2;
+          column -=2;
+        } while ((row < numRows) && (column >= 0));
+        row += 3;
+        column +=1;
+      }
+    } while ((row < numRows) || (column < numColumns));
+
+    if (resultOffset != parsedVersion_->getTotalCodewords()) {
+      throw ReaderException("Did not read all codewords");
+    }
+    return result;
+}
+
+bool BitMatrixParser::readModule(int row, int column, int numRows, int numColumns) {
+    // Adjust the row and column indices based on boundary wrapping
+    if (row < 0) {
+      row += numRows;
+      column += 4 - ((numRows + 4) & 0x07);
+    }
+    if (column < 0) {
+      column += numColumns;
+      row += 4 - ((numColumns + 4) & 0x07);
+    }
+    readBitMatrix_->set(column, row);
+    return bitMatrix_->get(column, row);
+  }
+
+int BitMatrixParser::readUtah(int row, int column, int numRows, int numColumns) {
+    int currentByte = 0;
+    if (readModule(row - 2, column - 2, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(row - 2, column - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(row - 1, column - 2, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(row - 1, column - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(row - 1, column, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(row, column - 2, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(row, column - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(row, column, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    return currentByte;
+  }
+
+int BitMatrixParser::readCorner1(int numRows, int numColumns) {
+    int currentByte = 0;
+    if (readModule(numRows - 1, 0, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(numRows - 1, 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(numRows - 1, 2, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 2, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(1, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(2, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(3, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    return currentByte;
+  }
+
+int BitMatrixParser::readCorner2(int numRows, int numColumns) {
+    int currentByte = 0;
+    if (readModule(numRows - 3, 0, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(numRows - 2, 0, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(numRows - 1, 0, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 4, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 3, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 2, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(1, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    return currentByte;
+  }
+
+int BitMatrixParser::readCorner3(int numRows, int numColumns) {
+    int currentByte = 0;
+    if (readModule(numRows - 1, 0, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(numRows - 1, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 3, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 2, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(1, numColumns - 3, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(1, numColumns - 2, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(1, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    return currentByte;
+  }
+
+int BitMatrixParser::readCorner4(int numRows, int numColumns) {
+    int currentByte = 0;
+    if (readModule(numRows - 3, 0, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(numRows - 2, 0, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(numRows - 1, 0, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 2, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(0, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(1, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(2, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    currentByte <<= 1;
+    if (readModule(3, numColumns - 1, numRows, numColumns)) {
+      currentByte |= 1;
+    }
+    return currentByte;
+  }
+
+Ref<BitMatrix> BitMatrixParser::extractDataRegion(Ref<BitMatrix> bitMatrix) {
+    int symbolSizeRows = parsedVersion_->getSymbolSizeRows();
+    int symbolSizeColumns = parsedVersion_->getSymbolSizeColumns();
+
+    if ((int)bitMatrix->getHeight() != symbolSizeRows) {
+      throw IllegalArgumentException("Dimension of bitMatrix must match the version size");
+    }
+
+    int dataRegionSizeRows = parsedVersion_->getDataRegionSizeRows();
+    int dataRegionSizeColumns = parsedVersion_->getDataRegionSizeColumns();
+
+    int numDataRegionsRow = symbolSizeRows / dataRegionSizeRows;
+    int numDataRegionsColumn = symbolSizeColumns / dataRegionSizeColumns;
+
+    int sizeDataRegionRow = numDataRegionsRow * dataRegionSizeRows;
+    int sizeDataRegionColumn = numDataRegionsColumn * dataRegionSizeColumns;
+
+    Ref<BitMatrix> bitMatrixWithoutAlignment(new BitMatrix(sizeDataRegionColumn, sizeDataRegionRow));
+    for (int dataRegionRow = 0; dataRegionRow < numDataRegionsRow; ++dataRegionRow) {
+      int dataRegionRowOffset = dataRegionRow * dataRegionSizeRows;
+      for (int dataRegionColumn = 0; dataRegionColumn < numDataRegionsColumn; ++dataRegionColumn) {
+        int dataRegionColumnOffset = dataRegionColumn * dataRegionSizeColumns;
+        for (int i = 0; i < dataRegionSizeRows; ++i) {
+          int readRowOffset = dataRegionRow * (dataRegionSizeRows + 2) + 1 + i;
+          int writeRowOffset = dataRegionRowOffset + i;
+          for (int j = 0; j < dataRegionSizeColumns; ++j) {
+            int readColumnOffset = dataRegionColumn * (dataRegionSizeColumns + 2) + 1 + j;
+            if (bitMatrix->get(readColumnOffset, readRowOffset)) {
+              int writeColumnOffset = dataRegionColumnOffset + j;
+              bitMatrixWithoutAlignment->set(writeColumnOffset, writeRowOffset);
+            }
+          }
+        }
+      }
+    }
+    return bitMatrixWithoutAlignment;
+}
+
+}
+}