As the assertion states, adaptiveThreshold() requires a single-channeled 8-bit image.

Assuming your floating-point image ranges from 0 to 1, which appears to be the case, you can convert the image by multiplying by 255 and casting to np.uint8:

float_img = np.random.random((4,4))
im = np.array(float_img * 255, dtype = np.uint8)
threshed = cv2.adaptiveThreshold(im, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 3, 0)

Here is the working code for how you were trying it:

img = np.stack((img,) * 3,-1)
img = img.astype(np.uint8)
grayed = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
thresh = cv2.threshold(grayed, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]

A simpler way of getting the same result is to invert the image yourself:

img = (255-img)
thresh = cv2.threshold(img, 0, 255, cv2.THRESH_OTSU)[1]

As you discovered, as you perform different operations on images, the image is required to be in different formats.

cv2.THRESH_BINARY_INV and cv2.THRESH_BINARY are designed to take a color image (and convert it to grayscale) so you need a three channel representation.

cv2.THRESH_OTSU works with grayscale images so one channel is okay for that.

Since your image was already grayscale from the start, you weren't able to convert it from color to grayscale nor did you really need to. I assume you were trying to invert the image but that's easy enough on your own (255-img).

At one point you tried to do an cv2.THRESH_OTSU with floating point values but cv2.THRESH_OTSU requires integers between 0 and 255.

If openCV had more user-friendly error messages it would really help with issues like these.

Let's say your 4D array of images is called img_stack with shape (60000,32,32,3).

You could do:

gray_stack = np.empty_like(img_stack[...,0])
for i in range(img_stack.shape[0]):
    gray_stack[i] = cv2.cvtColor(img_stack[i], cv2.COLOR_RGB2GRAY)

Resulting shape is (60000,32,32).

Or you could do:

gray_stack = np.empty_like(img_stack[...,:1])
for i in range(img_stack.shape[0]):
    gray_stack[i,:,:,0] = cv2.cvtColor(img_stack[i], cv2.COLOR_RGB2GRAY)

Resulting shape is (60000,32,32,1).

Bonus Tensorflow solution:

gray_stack = tf.image.rgb_to_grayscale(img_stack, name=None)

Resulting shape will be (60000,32,32,1).

The above OpenCV solutions might actually perform faster.

I assume that you have a 2D grayscale image, something like:

>>> import cv2
>>> img_gray = cv2.imread('./440px-Lenna.png', cv2.CV_LOAD_IMAGE_GRAYSCALE) # image take from http://en.wikipedia.org/wiki/Lenna

Now img_gray contains a gray scale image:

>>> print(img_gray.shape)
 (440, 440)

You can convert the image to BGR in an efficient way using cv2.cvtColor:

>>> img_bgr = cv2.cvtColor(img_gray, cv2.COLOR_GRAY2BGR)
>>> print(img_bgr.shape)
 (440, 440, 3)

Hi, i recently get into same problem also, what i did to solve is i changed the grayscale to color and replace frame.flatten() with frame.data and add bytesPerLine

I write it down here just in case someone need this. : - )

if len(cv_img.shape)<3:
    frame = cv2.cvtColor(cv_img, cv2.COLOR_GRAY2RGB)
else:
    frame = cv2.cvtColor(cv_img, cv2.COLOR_BGR2RGB)
h, w = cv_img.shape[:2]
bytesPerLine = 3 * w
qimage = QImage(frame.data, w, h, bytesPerLine, QImage.Format.Format_RGB888) 
#qimage = QImage(frame.flatten(), w, h, QImage.Format_RGB888)