ImgClusterDemo

import cv2
import numpy as np
from sklearn import preprocessing
import sklearn.cluster


DEFAULT_PARAMS = {
    #good features to track parmas
    "maxCorners":100,
    "qualityLevel":0.001,
    "minDistance":1,


    "filter_depth":2, #distance to expand pyramids

    #optic flow LK params
    "winSize":10,
    "patchSize":10,


    "corner_block_min":2,
    "corner_block_max":10,

    "open_windows":False,

    "tracked_noise":10,
    "ransac":10,

    "resamples":3,

    "threshold_abs":0,
    "threshold_rel":0.1,
    "num_peaks" :10000,


    "random_comparison_projection":False,
    "projection_seed":2,
}


def featureVectors(img, img_dict, coords, params=DEFAULT_PARAMS):
    if coords.shape == (2,):
        single =True
        N = 1
        coords = np.array([coords.astype(np.int16)])
    else:
        single = False
        N = coords.shape[0]

    #lazy build corner images when needed
    if not "corner_stack" in img_dict:
        img_dict["corner_stack"] = []

        for block_size in range(params["corner_block_min"], params["corner_block_max"]):

            img_dict["corner_stack"].append(
                cv2.cornerMinEigenVal(
                    src=img,
                    blockSize=block_size,
                )
            )

    n_features = 1 + len(img_dict["corner_stack"])
    result = np.zeros( (N, n_features))

    cursor = 0

    #add coordinate of sample
    #result = coord.copy()
    #add intensite of point
    result[:, cursor] = img[coords[:,1], coords[:,0]]
    cursor += 1

    for corner_img in img_dict["corner_stack"]:
        result[:, cursor] = corner_img[coords[:,1], coords[:,0]]
        cursor += 1

    if single:
        return result[0]
    return result


def all_features(cv_img, dtype=None):

    all =  np.vstack(np.mgrid[:cv_img.shape[1],:cv_img.shape[0]].T)

    if dtype == None:
        return all.astype(np.float32)
    elif dtype==np.int32:
        return all.astype(np.int32)


class Clusterer:
    def __init__(self, img, clusters = 8, params=DEFAULT_PARAMS):

        img_dict = {}
        #print all_features(img, params)
        Xraw = featureVectors(img, img_dict, all_features(img, dtype=np.int32), params)

        self.scaler = preprocessing.Scaler().fit(Xraw)
        X = self.scaler.transform(Xraw)

        self.clusters = clusters

        self.cluster = sklearn.cluster.MiniBatchKMeans(
            k=self.clusters,
            init='k-means++',
            max_iter=100,
            batch_size=100,
            verbose=0,
            compute_labels=True,
            random_state=None,
            tol=0.0,
            max_no_improvement=10,
            init_size=None,
            n_init=3,
            chunk_size=None
        )

        self.cluster.fit(X)

    def label(self, img, windowname="labels", params=DEFAULT_PARAMS):
        label_img = np.zeros(img.shape, dtype=np.uint8)
        img_dict = {}
        counts = np.zeros(self.clusters)

        coords = all_features(img, dtype=np.int32)
        f = featureVectors(img, img_dict, coords, params)
        fx = self.scaler.transform(f)
        labels = self.cluster.predict(fx)

        label_img[coords[:,1], coords[:, 0]] = labels[:] * (255/self.clusters)

        if "open_windows" in params:
            cv2.imshow(windowname, label_img)

        for label in range(self.clusters):
            counts[label] = np.count_nonzero(labels==label)

        return (label_img, counts)

    def labelOnly(self, img, groups, windowname="labels", update=False, params=DEFAULT_PARAMS):
        label_img = np.zeros(img.shape, dtype=np.uint8)
        img_dict = {}

        coords = all_features(img, dtype=np.int32)
        f = featureVectors(img, img_dict, coords, params)
        fx = self.scaler.transform(f)

        if update:
            self.cluster.partial_fit(fx)

        labels = self.cluster.predict(fx)

        for group_index, group in enumerate(groups):
            indeces = np.where(labels[:] == group)
            label_img[coords[indeces,1], coords[indeces, 0]] = ((group_index+1) * (255/(len(groups)+1)))

        if "open_windows" in params:
            cv2.imshow(windowname, label_img)

        return label_img



def cluster_behaviour_demo():
    img1 = cv2.pyrDown(cv2.imread("/home/tom/development/hw/git/ros/sonar_processing/training_data/cleaned_sauce/frame0108.jpg", flags=cv2.CV_LOAD_IMAGE_GRAYSCALE))
    img2 = cv2.pyrDown(cv2.imread("/home/tom/development/hw/git/ros/sonar_processing/training_data/cleaned_sauce/frame0109.jpg", flags=cv2.CV_LOAD_IMAGE_GRAYSCALE))

    combined = np.hstack([img1, img2])[:-10,:]

    cv2.imshow("raw", combined)

    clusterer = Clusterer(combined)

    (fully_labelled, counts)= clusterer.label(combined, windowname="cluster")

    selection =  counts.argsort()[0:4] #get 3 smallest

    labelled = clusterer.labelOnly(combined, selection)

    print "pre skel", np.unique(labelled)


if __name__ == "__main__":
    cluster_behaviour_demo()


    print "press escape or something on a focused openCV window to exit"
    cv2.waitKey()