from PIL import Image

def count_colors_2(image, maxcolors=2):
    # reducing colors
    image_reduced = image.quantize(colors=maxcolors, method=None, kmeans=0, palette=None)
    colors = image_reduced.getcolors(maxcolors)
    count_background_pixel = colors[0][0]
    count_filled_pixel = colors[1][0]
    return count_background_pixel, count_filled_pixel, colors


image = Image.open("25.bmp")
count_background_pixel, count_filled_pixel, colors = count_colors_2(image)
print("count_background_pixel: " + str(count_background_pixel))
print("count_filled_pixel: " + str(count_filled_pixel))
print(colors)

Quote:The function getcolors is limited to 256 colors, otherwise None is returned.

Quote:The function getcolors is limited to 256 colors, otherwise None is returned.

Quote:Nearly all computers and displays over the last five to ten years come standard with support for at least 16-bit color, with newer computers supporting 24-bit and 32-bit color. Is there a different between the different levels of color? The short answer is yes. All three color bit depths use red, blue and green as standard colors, but its the number of color combinations and alpha channel that makes the difference. Whether you are viewing pictures, watching a video, or playing a video game a higher color depth is more visually appealing.

16-bit color
With 16-bit color, also called High color, computers and monitors can display as many as 65,536 colors, which is adequate for most uses. However, graphic intensive video games and higher resolution video can benefit from and use the higher color depths.

24-bit color
Using 24-bit color, also called True color, computers and monitors can display as many as 16,777,216 different color combinations.

32-bit color
Like 24-bit color, 32-bit color supports 16,777,216 colors but has an alpha channel it can create more convincing gradients, shadows, and transparencies. With the alpha channel 32-bit color supports 4,294,967,296 color combinations.

As you increase the support for more colors, more memory is required. However, almost all computers today include video cards with enough memory to support 32-bit colors at most resolutions. Older computer and video cards may only be able to support up to 16-bit color.

Can my eyes tell a difference?
Most users cannot tell much of a difference between 16-bit and 32-bit. However, if you are using a program with gradients, shadows, transparency, or other visual effects that require multiple colors you may notice a difference.

Quote:Unfortunately, it wasn't at all clear to me that PDF documents already "know" whether they contain text, for example.

import os
# extract text
from PyPDF2 import PdfReader
# extract images
import fitz


def text_existing(path):
    obj = os.scandir(path)
    for entry in obj:
        if entry.name.endswith(".pdf"):
            reader = PdfReader(path + entry.name)
            text = reader.pages[0].extract_text()
            if text != " ":
                print(text)
            else:
                # page without text detected
                print("page contains no text")
    obj.close()


def image_existing(path):
    obj = os.scandir(path)
    for entry in obj:
        if entry.name.endswith(".pdf"):
            doc = fitz.open(path + entry.name)
            page = doc.load_page(0)
            image_xref = page.get_images()
            c = page.get_contents()
            if c is None:
                print("No image detected.")
            else:
                # get xref value of the image
                xref_value = image_xref[0][0]
                if xref_value > 0:
                    print("Image detected.")
    obj.close()


text_existing("D:/Daten/aktuell/detect_blank_pages/")
image_existing("D:/Daten/aktuell/detect_blank_pages/")

from PIL import Image
from pathlib import WindowsPath
import os
import numpy as np
from io import BytesIO
# extract images from pdf
import fitz


def examine_pdf_from_scanned_paper(path):
    # is image from pdf filled, or is it empty?
    # a FilledRatio < filledThreshold is recognized as empty
    filledThreshold = 0.001
    obj = os.scandir(path)
    for entry in obj:
        if entry.name.endswith(".pdf"):
            # extract image from single page pdf
            doc = fitz.open(path + "/" + str(entry.name))
            page = doc.load_page(0)
            image_xref = page.get_images()
            # get xref value of the image
            xref_value = image_xref[0][0]
            img_dictionary = doc.extract_image(xref_value)
            # get the actual image binary data
            img_binary = img_dictionary["image"]
            # create a BytesIO object to work with the image bytes
            image_io = BytesIO(img_binary)
            # this image was in the pdf
            # open the image using Pillow
            image = Image.open(image_io)
            # grayscale image
            im_gray = image.convert("L")
            # create numpy array
            im_gray = np.array(im_gray)
            # rgb values above threshold shall be white, under threshold black
            maxval = 255
            threshold = 200
            im_bin = (im_gray > threshold) * maxval
            image_bin = Image.fromarray(np.uint8(im_bin))
            image_bin.save("binarized.png")
            # image to numpy array
            rgb = np.array(image_bin).reshape(-1, 3)
            # counts pixel of binarized image, gets PrimaryColorRatio and FilledRatio.
            b24 = rgb[:, 0] * 65536 + rgb[:, 1] * 256 + rgb[:, 2]
            _, counts = np.unique(b24, return_counts=True)
            PrimaryColorRatio = max(counts) / max(len(b24), 1)
            FilledRatio = 1 - PrimaryColorRatio
            print("PrimaryColorRatio = ", PrimaryColorRatio)
            print("FilledRatio = ", FilledRatio)
            if FilledRatio > filledThreshold:
                print("image filled")
            else:
                print("image empty")
    obj.close()


examine_pdf_from_scanned_paper("D:/Daten/aktuell/detect_blank_pages_gut/")

import os

def text_existing(path):
    obj = os.scandir(path)
    for entry in obj:
        if entry.name.endswith(".pdf"):

from pathlib import Path

def text_existing(path):
    for entry in Path(path).glob("*.pdf"):