Image threshold algorithms to use on an x-ray image and detect bones

Question

I have a little project with OpenCV (python) where one of my steps is to take an x-ray image from the human body and convert it to a binary image where white pixels represent where some bone is present and black means there is no bone there.

Since sometimes "bone parts" can be darker than "non-bone parts" from another region, simple thresholding won't work. I also tried adaptive threshold and I couldn't see much difference.

I came up with a simple algorithm that applies a simple threshold for each row. Here is the code:

def threshhold(image, val):
    image = image.copy()

    for row_idx in range(image.shape[0]):
        max_row = image[row_idx].max()
        min_row = image[row_idx].min()
        tresh = np.median(image[row_idx]) + (val * (max_row - min_row))
        # Or use np.mean instead of np.median

        _, tresh = cv2.threshold(image[row_idx], tresh, 255, cv2.THRESH_BINARY)
        image[row_idx] = tresh.ravel()
    return image

And here is the code that does the same work but column-by-column instead of row-by-row:

def threshhold2(image, val):
    image = image.copy()

    for row_idx in range(image.shape[1]):
        max_row = image[:, row_idx].max()
        min_row = image[:, row_idx].min()
        tresh = np.median(image[:, row_idx]) + (val * (max_row - min_row))
        # Or use np.mean instead of np.median

        _, tresh = cv2.threshold(image[:, row_idx], tresh, 255, cv2.THRESH_BINARY)
        image[:, row_idx] = tresh.ravel()
    return image

This method works pretty well with images like this: Not quite well for this one but it is not that bad: Very terrible: Only the left half looks good

...

As you can see; this algorithm works well only for some images. I will be glad to see more experienced people's ideas.

Images are not for me by the way.

Entire source code:

import os
import cv2
import numpy as np

files_to_see = os.listdir("data_set")
files_to_see.sort()
current_file = 0

print(files_to_see)

def slice(image, size):
    out = []
    x_count = image.shape[1] // size
    y_count = image.shape[0] // size
    for y_idx in range(y_count):
        for x_idx in range(x_count):
            out.append(
                (
                    (y_idx, x_idx),
                    image[y_idx * size: (y_idx + 1) * size,
                          x_idx * size: (x_idx + 1) * size]
                )
            )
    return y_count, x_count, out

def normalize(image):
    image = image.copy()
    min_pix = image.min()
    max_pix = image.max()
    for y in range(image.shape[0]):
        for x in range(image.shape[1]):
            val = image[y, x]
            val -= min_pix
            val *= 255 / (max_pix - min_pix)
            image[y, x] = round(val)
    # image -= min_pix
    # image *= round(255 / (max_pix - min_pix))
    return image


def threshhold(image, val, method):
    image = image.copy()

    for row_idx in range(image.shape[0]):
        max_row = image[row_idx].max()
        min_row = image[row_idx].min()
        # tresh = np.median(image[row_idx]) + (val * (max_row - min_row))
        tresh = method(image[row_idx]) + (val * (max_row - min_row))

        _, tresh = cv2.threshold(image[row_idx], tresh, 255, cv2.THRESH_BINARY)
        image[row_idx] = tresh.ravel()
    return image

def threshhold2(image, val, method):
    image = image.copy()

    for row_idx in range(image.shape[1]):
        max_row = image[:, row_idx].max()
        min_row = image[:, row_idx].min()
        tresh = method(image[:, row_idx]) + (val * (max_row - min_row))

        _, tresh = cv2.threshold(image[:, row_idx], tresh, 255, cv2.THRESH_BINARY)
        image[:, row_idx] = tresh.ravel()
    return image

def recalculate_threshhold(v):
    global original_current_image, thresh_current_image, y_c, x_c, slices

    method = np.mean
    if cv2.getTrackbarPos("method", "xb labeler") == 0:
        method = np.median
    thresh_current_image = threshhold2(original_current_image, cv2.getTrackbarPos("threshhold_value", "xb labeler") / 1000, method)
    y_c, x_c, slices = slice(thresh_current_image, 128)

def thresh_current_image_mouse_event(event, x, y, flags, param):
    if event == 1:
        print(x // 128, y // 128)
        cv2.imshow("slice", slices[(x // 128) + (y // 128) * x_c][1])

cv2.namedWindow("xb labeler")
cv2.createTrackbar("threshhold_value", "xb labeler", 0, 1000, recalculate_threshhold)
cv2.createTrackbar("method", "xb labeler", 0, 1, recalculate_threshhold)

cv2.namedWindow("thresh_current_image")
cv2.setMouseCallback("thresh_current_image", thresh_current_image_mouse_event)

def init():
    global original_current_image, thresh_current_image, x_c, y_c, slices, files_to_see, current_file
    original_current_image = cv2.imread("data_set/" + files_to_see[current_file], cv2.CV_8UC1)
    original_current_image = cv2.resize(original_current_image, (512, 512))
    original_current_image = normalize(original_current_image)
    original_current_image = cv2.GaussianBlur(original_current_image, (5, 5), 10)
    recalculate_threshhold(1)
    y_c, x_c, slices = slice(thresh_current_image, 128)

init()

while True:

    cv2.imshow("thresh_current_image", thresh_current_image)
    cv2.imshow("xb labeler", original_current_image)
    k = cv2.waitKey(1)
    if k == ord('p'):
        cv2.imwrite("ssq.png", thresh_current_image)
        current_file += 1
        init()

cv2.destroyAllWindows()

EDIT: Added original images: