301 lines
8.3 KiB
Java
301 lines
8.3 KiB
Java
|
/*This is a Java Program to implement 2D KD Tree and find the nearest neighbor for dynamic input set. In computer science, a k-d tree (short for k-dimensional tree) is a space-partitioning data structure for organizing points in a k-dimensional space. k-d trees are a useful data structure for several applications, such as searches involving a multidimensional search key (e.g. range searches and nearest neighbor searches). k-d trees are a special case of binary space partitioning trees.*/
|
||
|
|
|
||
|
|
//This is a java program to find nearest neighbor for dynamic data set
|
||
|
|
import java.io.IOException;
|
||
|
|
import java.util.Scanner;
|
||
|
|
|
||
|
|
class KDN
|
||
|
|
{
|
||
|
|
int axis;
|
||
|
|
double[] x;
|
||
|
|
int id;
|
||
|
|
boolean checked;
|
||
|
|
boolean orientation;
|
||
|
|
|
||
|
|
KDN Parent;
|
||
|
|
KDN Left;
|
||
|
|
KDN Right;
|
||
|
|
|
||
|
|
public KDN(double[] x0, int axis0)
|
||
|
|
{
|
||
|
|
x = new double[2];
|
||
|
|
axis = axis0;
|
||
|
|
for (int k = 0; k < 2; k++)
|
||
|
|
x[k] = x0[k];
|
||
|
|
Left = Right = Parent = null;
|
||
|
|
checked = false;
|
||
|
|
id = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
public KDN FindParent(double[] x0)
|
||
|
|
{
|
||
|
|
KDN parent = null;
|
||
|
|
KDN next = this;
|
||
|
|
int split;
|
||
|
|
while (next != null)
|
||
|
|
{
|
||
|
|
split = next.axis;
|
||
|
|
parent = next;
|
||
|
|
if (x0[split] > next.x[split])
|
||
|
|
next = next.Right;
|
||
|
|
else
|
||
|
|
next = next.Left;
|
||
|
|
}
|
||
|
|
return parent;
|
||
|
|
}
|
||
|
|
|
||
|
|
public KDN Insert(double[] p)
|
||
|
|
{
|
||
|
|
x = new double[2];
|
||
|
|
KDN parent = FindParent(p);
|
||
|
|
if (equal(p, parent.x, 2) == true)
|
||
|
|
return null;
|
||
|
|
KDN newNode = new KDN(p, parent.axis + 1 < 2 ? parent.axis + 1 : 0);
|
||
|
|
newNode.Parent = parent;
|
||
|
|
if (p[parent.axis] > parent.x[parent.axis])
|
||
|
|
{
|
||
|
|
parent.Right = newNode;
|
||
|
|
newNode.orientation = true; //
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
parent.Left = newNode;
|
||
|
|
newNode.orientation = false; //
|
||
|
|
}
|
||
|
|
return newNode;
|
||
|
|
}
|
||
|
|
|
||
|
|
boolean equal(double[] x1, double[] x2, int dim)
|
||
|
|
{
|
||
|
|
for (int k = 0; k < dim; k++)
|
||
|
|
{
|
||
|
|
if (x1[k] != x2[k])
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
double distance2(double[] x1, double[] x2, int dim)
|
||
|
|
{
|
||
|
|
double S = 0;
|
||
|
|
for (int k = 0; k < dim; k++)
|
||
|
|
S += (x1[k] - x2[k]) * (x1[k] - x2[k]);
|
||
|
|
return S;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
class KDTreeDynamic
|
||
|
|
{
|
||
|
|
KDN Root;
|
||
|
|
|
||
|
|
int TimeStart, TimeFinish;
|
||
|
|
int CounterFreq;
|
||
|
|
|
||
|
|
double d_min;
|
||
|
|
KDN nearest_neighbour;
|
||
|
|
|
||
|
|
int KD_id;
|
||
|
|
|
||
|
|
int nList;
|
||
|
|
|
||
|
|
KDN CheckedNodes[];
|
||
|
|
int checked_nodes;
|
||
|
|
KDN List[];
|
||
|
|
|
||
|
|
double x_min[], x_max[];
|
||
|
|
boolean max_boundary[], min_boundary[];
|
||
|
|
int n_boundary;
|
||
|
|
|
||
|
|
public KDTreeDynamic(int i)
|
||
|
|
{
|
||
|
|
Root = null;
|
||
|
|
KD_id = 1;
|
||
|
|
nList = 0;
|
||
|
|
List = new KDN[i];
|
||
|
|
CheckedNodes = new KDN[i];
|
||
|
|
max_boundary = new boolean[2];
|
||
|
|
min_boundary = new boolean[2];
|
||
|
|
x_min = new double[2];
|
||
|
|
x_max = new double[2];
|
||
|
|
}
|
||
|
|
|
||
|
|
public boolean add(double[] x)
|
||
|
|
{
|
||
|
|
if (nList >= 2000000 - 1)
|
||
|
|
return false; // can't add more points
|
||
|
|
if (Root == null)
|
||
|
|
{
|
||
|
|
Root = new KDN(x, 0);
|
||
|
|
Root.id = KD_id++;
|
||
|
|
List[nList++] = Root;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
KDN pNode;
|
||
|
|
if ((pNode = Root.Insert(x)) != null)
|
||
|
|
{
|
||
|
|
pNode.id = KD_id++;
|
||
|
|
List[nList++] = pNode;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
public KDN find_nearest(double[] x)
|
||
|
|
{
|
||
|
|
if (Root == null)
|
||
|
|
return null;
|
||
|
|
checked_nodes = 0;
|
||
|
|
KDN parent = Root.FindParent(x);
|
||
|
|
nearest_neighbour = parent;
|
||
|
|
d_min = Root.distance2(x, parent.x, 2);
|
||
|
|
;
|
||
|
|
if (parent.equal(x, parent.x, 2) == true)
|
||
|
|
return nearest_neighbour;
|
||
|
|
search_parent(parent, x);
|
||
|
|
uncheck();
|
||
|
|
return nearest_neighbour;
|
||
|
|
}
|
||
|
|
|
||
|
|
public void check_subtree(KDN node, double[] x)
|
||
|
|
{
|
||
|
|
if ((node == null) || node.checked)
|
||
|
|
return;
|
||
|
|
CheckedNodes[checked_nodes++] = node;
|
||
|
|
node.checked = true;
|
||
|
|
set_bounding_cube(node, x);
|
||
|
|
int dim = node.axis;
|
||
|
|
double d = node.x[dim] - x[dim];
|
||
|
|
if (d * d > d_min)
|
||
|
|
{
|
||
|
|
if (node.x[dim] > x[dim])
|
||
|
|
check_subtree(node.Left, x);
|
||
|
|
else
|
||
|
|
check_subtree(node.Right, x);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
check_subtree(node.Left, x);
|
||
|
|
check_subtree(node.Right, x);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public void set_bounding_cube(KDN node, double[] x)
|
||
|
|
{
|
||
|
|
if (node == null)
|
||
|
|
return;
|
||
|
|
int d = 0;
|
||
|
|
double dx;
|
||
|
|
for (int k = 0; k < 2; k++)
|
||
|
|
{
|
||
|
|
dx = node.x[k] - x[k];
|
||
|
|
if (dx > 0)
|
||
|
|
{
|
||
|
|
dx *= dx;
|
||
|
|
if (!max_boundary[k])
|
||
|
|
{
|
||
|
|
if (dx > x_max[k])
|
||
|
|
x_max[k] = dx;
|
||
|
|
if (x_max[k] > d_min)
|
||
|
|
{
|
||
|
|
max_boundary[k] = true;
|
||
|
|
n_boundary++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
dx *= dx;
|
||
|
|
if (!min_boundary[k])
|
||
|
|
{
|
||
|
|
if (dx > x_min[k])
|
||
|
|
x_min[k] = dx;
|
||
|
|
if (x_min[k] > d_min)
|
||
|
|
{
|
||
|
|
min_boundary[k] = true;
|
||
|
|
n_boundary++;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
d += dx;
|
||
|
|
if (d > d_min)
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (d < d_min)
|
||
|
|
{
|
||
|
|
d_min = d;
|
||
|
|
nearest_neighbour = node;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public KDN search_parent(KDN parent, double[] x)
|
||
|
|
{
|
||
|
|
for (int k = 0; k < 2; k++)
|
||
|
|
{
|
||
|
|
x_min[k] = x_max[k] = 0;
|
||
|
|
max_boundary[k] = min_boundary[k] = false; //
|
||
|
|
}
|
||
|
|
n_boundary = 0;
|
||
|
|
KDN search_root = parent;
|
||
|
|
while (parent != null && (n_boundary != 2 * 2))
|
||
|
|
{
|
||
|
|
check_subtree(parent, x);
|
||
|
|
search_root = parent;
|
||
|
|
parent = parent.Parent;
|
||
|
|
}
|
||
|
|
return search_root;
|
||
|
|
}
|
||
|
|
|
||
|
|
public void uncheck()
|
||
|
|
{
|
||
|
|
for (int n = 0; n < checked_nodes; n++)
|
||
|
|
CheckedNodes[n].checked = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
public class Dynamic_Nearest
|
||
|
|
{
|
||
|
|
|
||
|
|
public static void main(String args[]) throws IOException
|
||
|
|
{
|
||
|
|
int numpoints = 10;
|
||
|
|
Scanner sc = new Scanner(System.in);
|
||
|
|
KDTreeDynamic kdt = new KDTreeDynamic(numpoints);
|
||
|
|
double x[] = new double[2];
|
||
|
|
System.out.println("Enter the first 10 data set : <x> <y>");
|
||
|
|
for (int i = 0; i < numpoints; i++)
|
||
|
|
{
|
||
|
|
x[0] = sc.nextDouble();
|
||
|
|
x[1] = sc.nextDouble();
|
||
|
|
kdt.add(x);
|
||
|
|
}
|
||
|
|
System.out.println("Enter the co-ordinates of the point: <x> <y>");
|
||
|
|
double sx = sc.nextDouble();
|
||
|
|
double sy = sc.nextDouble();
|
||
|
|
double s[] = { sx, sy };
|
||
|
|
KDN kdn = kdt.find_nearest(s);
|
||
|
|
System.out.println("The nearest neighbor for the static data set is: ");
|
||
|
|
System.out.println("(" + kdn.x[0] + " , " + kdn.x[1] + ")");
|
||
|
|
sc.close();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
Enter the first 10 data set :
|
||
|
|
1.2 3.3
|
||
|
|
2.3 3.4
|
||
|
|
4.5 5.6
|
||
|
|
6.7 7.8
|
||
|
|
8.9 9.0
|
||
|
|
10.1 11.3
|
||
|
|
15.6 19.4
|
||
|
|
20.5 25.4
|
||
|
|
52.8 65.3
|
||
|
|
62.6 56.3
|
||
|
|
|
||
|
|
Enter the co-ordinates of the point: <x> <y>
|
||
|
|
60 34.2
|
||
|
|
|
||
|
|
The nearest neighbor for the static data set is:
|
||
|
|
(62.6 , 56.3)
|