static extractPureBits(image) {
			const leftTopBlack = image.getTopLeftOnBit();
			const rightBottomBlack = image.getBottomRightOnBit();
			if (leftTopBlack === null || rightBottomBlack === null) {
				throw new NotFoundException();
			}
			const moduleSize = this.moduleSize(leftTopBlack, image);
			let top = leftTopBlack[1];
			let bottom = rightBottomBlack[1];
			let left = leftTopBlack[0];
			let right = rightBottomBlack[0];
			// Sanity check!
			if (left >= right || top >= bottom) {
				throw new NotFoundException();
			}
			if (bottom - top !== right - left) {
				// Special case, where bottom-right module wasn't black so we found something else in the last row
				// Assume it's a square, so use height as the width
				right = left + (bottom - top);
				if (right >= image.getWidth()) {
					// Abort if that would not make sense -- off image
					throw new NotFoundException();
				}
			}
			const matrixWidth = Math.round((right - left + 1) / moduleSize);
			const matrixHeight = Math.round((bottom - top + 1) / moduleSize);
			if (matrixWidth <= 0 || matrixHeight <= 0) {
				throw new NotFoundException();
			}
			if (matrixHeight !== matrixWidth) {
				// Only possibly decode square regions
				throw new NotFoundException();
			}
			// Push in the "border" by half the module width so that we start
			// sampling in the middle of the module. Just in case the image is a
			// little off, this will help recover.
			const nudge = /*(int) */ Math.floor(moduleSize / 2.0);
			top += nudge;
			left += nudge;
			// But careful that this does not sample off the edge
			// "right" is the farthest-right valid pixel location -- right+1 is not necessarily
			// This is positive by how much the inner x loop below would be too large
			const nudgedTooFarRight = left + /*(int) */ Math.floor((matrixWidth - 1) * moduleSize) - right;
			if (nudgedTooFarRight > 0) {
				if (nudgedTooFarRight > nudge) {
					// Neither way fits; abort
					throw new NotFoundException();
				}
				left -= nudgedTooFarRight;
			}
			// See logic above
			const nudgedTooFarDown = top + /*(int) */ Math.floor((matrixHeight - 1) * moduleSize) - bottom;
			if (nudgedTooFarDown > 0) {
				if (nudgedTooFarDown > nudge) {
					// Neither way fits; abort
					throw new NotFoundException();
				}
				top -= nudgedTooFarDown;
			}
			// Now just read off the bits
			const bits = new BitMatrix(matrixWidth, matrixHeight);
			for (let y = 0; y < matrixHeight; y++) {
				const iOffset = top + /*(int) */ Math.floor(y * moduleSize);
				for (let x = 0; x < matrixWidth; x++) {
					if (image.get(left + /*(int) */ Math.floor(x * moduleSize), iOffset)) {
						bits.set(x, y);
					}
				}
			}
			return bits;
		}
This method detects a code in a "pure" image -- that is, pure monochrome image
which contains only an unrotated, unskewed, image of a code, with some white border
around it. This is a specialized method that works exceptionally fast in this special
case.

@see com.google.zxing.datamatrix.DataMatrixReader#extractPureBits(BitMatrix)