kmeans | k-means clustering algorithm implementation written in Go | Learning library

I started getting the same error recently. It might have had something to do with a macOS upgrade from Sierra to Catalina, but I found that it was having an issue calculating kMeans when n_clusters = 1. In the following code, I changed my range to be 2:10 instead of 1:10, and it started working.

Here is my attempt at reverse engeneering the plot:

My solution involves creating a binary object mask where all the objects are colored in white and the background in black. I then extract each object based on area, from smallest to smallest. I use this "isolated object" mask to segment each object in the original image. I then write the result to disk. These are the steps:

1. Resize the image (your original input is gigantic)
2. Convert to grayscale
3. Extract each object based on area from largest to smallest
4. Create a binary mask of the isolated object
5. Apply a little bit of morphology to enhance the mask
6. Mask the original BGR image with the binary mask
7. Apply flood-fill to color the background with white
8. Save image to disk
9. Repeat the process for all the objects in the image

Let's see the code. Through the script I use two helper functions: writeImage and findBiggestBlob. The first function is pretty self-explanatory. The second function creates a binary mask of the biggest blob in a binary input image. Both functions are presented here:

A possible solution, where Calculate is determined in the first mutate (therefore, outside if_else), which can correspond to a very complicated calculation, as you declare you are needing:

The procedure would be as follow:

Let us assume that you want to visualize the 8th layer from VGG. This layer's output might have the shape (64, 64, 256) (I just took some random numbers, this does not correspond to actual VGG). This means that you have 4096 256-dimensional vectors (for one specific image). Now you can apply K-Means on these vectors (for example with 5 clusters) and then color your image corresponding to the clustering result. The coloring is easy, since the 64x64 feature map represents a scaled down version of your image, and thus you just color the corresponding image region for each of these vectors.

I don't know if it might be a good idea to do the K-Means clustering on the combined output of many images, theoretically doing it on many images and one a single one should both give good results (even though for many images you probably would increase the number of clusters to account for the higher variation in your feature vectors).

For this problem, I don't recommend using Kmeans color quantization since this technique is usually reserved for a situation where there are various colors and you want to segment them into dominant color blocks. Take a look at this previous answer for a typical use case. Since your CT scan images are grayscale, Kmeans would not perform very well. Here's a potential solution using simple image processing with OpenCV:

1. Obtain binary image. Load input image, convert to grayscale, Otsu's threshold, and find contours.

2. Create a blank mask to extract desired objects. We can use np.zeros() to create a empty mask with the same size as the input image.

3. Filter contours using contour area and aspect ratio. We search for the lung objects by ensuring that contours are within a specified area threshold as well as aspect ratio. We use cv2.contourArea(), cv2.arcLength(), and cv2.approxPolyDP() for contour perimeter and contour shape approximation. If we have have found our lung object, we utilize cv2.drawContours() to fill in our mask with white to represent the objects that we want to extract.

4. Bitwise-and mask with original image. Finally we convert the mask to grayscale and bitwise-and with cv2.bitwise_and() to obtain our result.

Here is our image processing pipeline visualized step-by-step:

Grayscale -> Otsu's threshold

Detected objects to extract highlighted in green -> Filled mask

Bitwise-and to get our result -> Optional result with white background instead

Code

You've started on the right approach. Let's try to pull all the lines out of the loop one by one. First, the predictions:

Don't think KMeans has outliers/noise. If you have a look at https://scikit-learn.org/stable/modules/clustering.html#clustering there's a good pictorial representation - the black dots represent noise or "outliers".

Maybe DBSCAN will suit your needs better

In the function to visualize the clusters, you need ax.legend instead of plt.legend