com.venky.clustering.Clusterer Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of common Show documentation
Commonly used programming tasks in java
The newest version!
package com.venky.clustering;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Clusterer {
    private Metric metric;
    private CenterFinderBuilder centerFinderBuilder ;
    private ClusterBuilder clusterBuilder ;
    
    private static class DefaultCenterFinderBuilder implements CenterFinderBuilder {
	    private CenterFinder centerFinder;
    	public DefaultCenterFinderBuilder(CenterFinder finder) {
    		this.centerFinder = finder;
		}
		@Override
		public CenterFinder build(Cluster cluster) {
			return this.centerFinder;
		}
    	
    }


    public Clusterer(CenterFinderBuilder cf, Metric m){
        this (null,cf,m);
    }
    public Clusterer(ClusterBuilder clusterBuilder, CenterFinderBuilder cf, Metric m){
        this.centerFinderBuilder = cf;
        this.metric = m;
        if (clusterBuilder == null){
            this.clusterBuilder = new ClusterBuilder() {
                @Override
                public Cluster init(CenterFinderBuilder cf, Metric m) {
                    return new Cluster<>(cf,m);
                }

                @Override
                public Cluster init(T fixedCentroid, Metric metric) {
                    return new Cluster<>(fixedCentroid,metric);
                }
            };
        }else {
            this.clusterBuilder = clusterBuilder;
        }

    }

    public Clusterer(CenterFinder cf, Metric m){
    	this(new DefaultCenterFinderBuilder(cf),m);
    }
    public Clusterer(Metric m){
    	this(new DefaultCenterFinderBuilder(null),m);
    }

    public Metric getMetric(){
        return metric;
    }
    
    public List> cluster(Collection points, List centroids){
        List> clusters = new ArrayList<>();
        for (T centroid: centroids){
            Cluster init = clusterBuilder.init(centroid,metric);
            clusters.add(init);
        }
        
        for (T p : points){
            int closestCentroidIndex = -1;
            double distanceToClosestCentroid = Double.POSITIVE_INFINITY;
            
            for (int i = 0; i < centroids.size() ; i ++ ){
                double distanceToCentroid = metric.distance(centroids.get(i),p);
                if (distanceToClosestCentroid > distanceToCentroid){
                    distanceToClosestCentroid = distanceToCentroid; 
                    closestCentroidIndex = i ;
                }
            }
            if (closestCentroidIndex >= 0 ){
                clusters.get(closestCentroidIndex).addPoint(p);
            }
        }
        return clusters;
    }
    
    public List> cluster(Collection points, int maxClusters){
        return cluster(points,new MaxClustersCreated(maxClusters));
    }
    
    public List> cluster(Collection points,StopCriteria stopCriteria){
        List> clusters = new ArrayList>();
        for (T point: points){
            Cluster init = clusterBuilder.init(centerFinderBuilder,metric);
            init.addPoint(point);
            clusters.add(init);
        }
        
        Map,Map,Double>> distances = new HashMap, Map,Double>>();
        Cluster clusterGrown = null; 
        Cluster clusterDestroyed = null;
        while (!stopCriteria.canStop(clusters,clusterGrown,clusterDestroyed)){

            int indexGrown = 0; 
            int indexDestroyed = 0; 
            double minDistance = Double.POSITIVE_INFINITY;
            for (int i = 0 ; i < clusters.size() ; i ++ ){
                Cluster inspected = clusters.get(i);
                Map,Double> inspectedDistances = distances.get(inspected);
                if (inspectedDistances == null){ 
                    inspectedDistances = new HashMap, Double>();
                    distances.put(inspected, inspectedDistances);
                }
                for (int j = i +1 ; j < clusters.size() ; j ++){
                    Cluster other = clusters.get(j);
                    Double distance = inspectedDistances.get(other); 
                    if (distance == null){
                        if (inspected.centroid() != null){
                            distance = inspected.centroidDistance(other);
                        }else {
                            distance = inspected.distance(other).getMinDistance();
                        }
                        inspectedDistances.put(other, distance);
                    }
                    
                    if (minDistance >  distance){
                        minDistance = distance;
                        indexGrown = i ;
                        indexDestroyed = j ;
                    }
                }
            }
            if (minDistance == Double.POSITIVE_INFINITY){
                break; 
            }
            
            clusterGrown = clusters.get(indexGrown);
            clusterDestroyed = clusters.remove(indexDestroyed); //Note index Destroyed >= indexGrown.
            clusterGrown.addAll(clusterDestroyed);
            distances.remove(clusterGrown);
            distances.remove(clusterDestroyed);
            for (Cluster remaining: distances.keySet()){
                distances.get(remaining).remove(clusterGrown);
                distances.get(remaining).remove(clusterDestroyed);
            }

        }
        return clusters;
    }
}