home | career | drupal | java | mac | mysql | perl | scala | uml | unix  

Java example source code file (DBSCANClusterer.java)

This example Java source code file (DBSCANClusterer.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

arraylist, cluster, clusterable, collection, dbscanclusterer, hashmap, list, map, noise, notpositiveexception, nullargumentexception, part_of_cluster, pointstatus, util

The DBSCANClusterer.java Java example source code

 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *      http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * See the License for the specific language governing permissions and
 * limitations under the License.
package org.apache.commons.math3.stat.clustering;

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

import org.apache.commons.math3.exception.NotPositiveException;
import org.apache.commons.math3.exception.NullArgumentException;
import org.apache.commons.math3.util.MathUtils;

 * DBSCAN (density-based spatial clustering of applications with noise) algorithm.
 * <p>
 * The DBSCAN algorithm forms clusters based on the idea of density connectivity, i.e.
 * a point p is density connected to another point q, if there exists a chain of
 * points p<sub>i, with i = 1 .. n and p1 = p and pn = q,
 * such that each pair <p<sub>i, pi+1> is directly density-reachable.
 * A point q is directly density-reachable from point p if it is in the ε-neighborhood
 * of this point.
 * <p>
 * Any point that is not density-reachable from a formed cluster is treated as noise, and
 * will thus not be present in the result.
 * <p>
 * The algorithm requires two parameters:
 * <ul>
 *   <li>eps: the distance that defines the ε-neighborhood of a point
 *   <li>minPoints: the minimum number of density-connected points required to form a cluster
 * </ul>
 * <p>
 * <b>Note: as DBSCAN is not a centroid-based clustering algorithm, the resulting
 * {@link Cluster} objects will have no defined center, i.e. {@link Cluster#getCenter()} will
 * return {@code null}.
 * @param <T> type of the points to cluster
 * @see <a href="http://en.wikipedia.org/wiki/DBSCAN">DBSCAN (wikipedia)
 * @see <a href="http://www.dbs.ifi.lmu.de/Publikationen/Papers/KDD-96.final.frame.pdf">
 * A Density-Based Algorithm for Discovering Clusters in Large Spatial Databases with Noise</a>
 * @since 3.1
 * @deprecated As of 3.2 (to be removed in 4.0),
 * use {@link org.apache.commons.math3.ml.clustering.DBSCANClusterer} instead
public class DBSCANClusterer<T extends Clusterable {

    /** Maximum radius of the neighborhood to be considered. */
    private final double              eps;

    /** Minimum number of points needed for a cluster. */
    private final int                 minPts;

    /** Status of a point during the clustering process. */
    private enum PointStatus {
        /** The point has is considered to be noise. */
        /** The point is already part of a cluster. */

     * Creates a new instance of a DBSCANClusterer.
     * @param eps maximum radius of the neighborhood to be considered
     * @param minPts minimum number of points needed for a cluster
     * @throws NotPositiveException if {@code eps < 0.0} or {@code minPts < 0}
    public DBSCANClusterer(final double eps, final int minPts)
        throws NotPositiveException {
        if (eps < 0.0d) {
            throw new NotPositiveException(eps);
        if (minPts < 0) {
            throw new NotPositiveException(minPts);
        this.eps = eps;
        this.minPts = minPts;

     * Returns the maximum radius of the neighborhood to be considered.
     * @return maximum radius of the neighborhood
    public double getEps() {
        return eps;

     * Returns the minimum number of points needed for a cluster.
     * @return minimum number of points needed for a cluster
    public int getMinPts() {
        return minPts;

     * Performs DBSCAN cluster analysis.
     * <p>
     * <b>Note: as DBSCAN is not a centroid-based clustering algorithm, the resulting
     * {@link Cluster} objects will have no defined center, i.e. {@link Cluster#getCenter()} will
     * return {@code null}.
     * @param points the points to cluster
     * @return the list of clusters
     * @throws NullArgumentException if the data points are null
    public List<Cluster cluster(final Collection points) throws NullArgumentException {

        // sanity checks

        final List<Cluster clusters = new ArrayList>();
        final Map<Clusterable visited = new HashMap, PointStatus>();

        for (final T point : points) {
            if (visited.get(point) != null) {
            final List<T> neighbors = getNeighbors(point, points);
            if (neighbors.size() >= minPts) {
                // DBSCAN does not care about center points
                final Cluster<T> cluster = new Cluster(null);
                clusters.add(expandCluster(cluster, point, neighbors, points, visited));
            } else {
                visited.put(point, PointStatus.NOISE);

        return clusters;

     * Expands the cluster to include density-reachable items.
     * @param cluster Cluster to expand
     * @param point Point to add to cluster
     * @param neighbors List of neighbors
     * @param points the data set
     * @param visited the set of already visited points
     * @return the expanded cluster
    private Cluster<T> expandCluster(final Cluster cluster,
                                     final T point,
                                     final List<T> neighbors,
                                     final Collection<T> points,
                                     final Map<Clusterable visited) {
        visited.put(point, PointStatus.PART_OF_CLUSTER);

        List<T> seeds = new ArrayList(neighbors);
        int index = 0;
        while (index < seeds.size()) {
            final T current = seeds.get(index);
            PointStatus pStatus = visited.get(current);
            // only check non-visited points
            if (pStatus == null) {
                final List<T> currentNeighbors = getNeighbors(current, points);
                if (currentNeighbors.size() >= minPts) {
                    seeds = merge(seeds, currentNeighbors);

            if (pStatus != PointStatus.PART_OF_CLUSTER) {
                visited.put(current, PointStatus.PART_OF_CLUSTER);

        return cluster;

     * Returns a list of density-reachable neighbors of a {@code point}.
     * @param point the point to look for
     * @param points possible neighbors
     * @return the List of neighbors
    private List<T> getNeighbors(final T point, final Collection points) {
        final List<T> neighbors = new ArrayList();
        for (final T neighbor : points) {
            if (point != neighbor && neighbor.distanceFrom(point) <= eps) {
        return neighbors;

     * Merges two lists together.
     * @param one first list
     * @param two second list
     * @return merged lists
    private List<T> merge(final List one, final List two) {
        final Set<T> oneSet = new HashSet(one);
        for (T item : two) {
            if (!oneSet.contains(item)) {
        return one;

Other Java examples (source code examples)

Here is a short list of links related to this Java DBSCANClusterer.java source code file:

my book on functional programming


new blog posts


Copyright 1998-2019 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.