docs: private static BitMatrix extractPureBits(BitMatrix image) throws NotFoundException {
  
      int[] leftTopBlack = image.getTopLeftOnBit();
      int[] rightBottomBlack = image.getBottomRightOnBit();
      if (leftTopBlack == null || rightBottomBlack == null) {
        throw NotFoundException.getNotFoundInstance();
      }
  
      float moduleSize = moduleSize(leftTopBlack, image);
  
      int top = leftTopBlack[1];
      int bottom = rightBottomBlack[1];
      int left = leftTopBlack[0];
      int right = rightBottomBlack[0];
  
      // Sanity check!
      if (left >= right || top >= bottom) {
        throw NotFoundException.getNotFoundInstance();
      }
  
      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 NotFoundException.getNotFoundInstance();
        }
      }
  
      int matrixWidth = Math.round((right - left + 1) / moduleSize);
      int matrixHeight = Math.round((bottom - top + 1) / moduleSize);
      if (matrixWidth <= 0 || matrixHeight <= 0) {
        throw NotFoundException.getNotFoundInstance();
      }
      if (matrixHeight != matrixWidth) {
        // Only possibly decode square regions
        throw NotFoundException.getNotFoundInstance();
      }
  
      // 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.
      int nudge = (int) (moduleSize / 2.0f);
      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
      int nudgedTooFarRight = left + (int) ((matrixWidth - 1) * moduleSize) - right;
      if (nudgedTooFarRight > 0) {
        if (nudgedTooFarRight > nudge) {
          // Neither way fits; abort
          throw NotFoundException.getNotFoundInstance();
        }
        left -= nudgedTooFarRight;
      }
      // See logic above
      int nudgedTooFarDown = top + (int) ((matrixHeight - 1) * moduleSize) - bottom;
      if (nudgedTooFarDown > 0) {
        if (nudgedTooFarDown > nudge) {
          // Neither way fits; abort
          throw NotFoundException.getNotFoundInstance();
        }
        top -= nudgedTooFarDown;
      }
  
      // Now just read off the bits
      BitMatrix bits = new BitMatrix(matrixWidth, matrixHeight);
      for (int y = 0; y < matrixHeight; y++) {
        int iOffset = top + (int) (y * moduleSize);
        for (int x = 0; x < matrixWidth; x++) {
          if (image.get(left + (int) (x * moduleSize), iOffset)) {
            bits.set(x, y);
          }
        }
      }
      return bits;
    }