/*
* Copyright (c) 2003, the JUNG Project and the Regents of the University
* of California
* All rights reserved.
*
* This software is open-source under the BSD license; see either
* "license.txt" or
* http://jung.sourceforge.net/license.txt for a description.
*/
package edu.uci.ics.jung.algorithms.layout3d;
import java.util.ArrayList;
import java.util.Collection;
import java.util.ConcurrentModificationException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.vecmath.Point3f;
import javax.vecmath.Vector3f;
import org.apache.commons.collections15.Factory;
import org.apache.commons.collections15.map.LazyMap;
import edu.uci.ics.jung.algorithms.util.IterativeContext;
import edu.uci.ics.jung.graph.Graph;
/**
* Implements a self-organizing map layout algorithm, based on Meyer's
* self-organizing graph methods.
*
* @author Yan Biao Boey
*/
public class ISOMLayout<V, E> extends AbstractLayout<V,E> implements IterativeContext {
Map<V, ISOMVertexData> isomVertexData =
LazyMap.decorate(new HashMap<V, ISOMVertexData>(),
new Factory<ISOMVertexData>() {
public ISOMVertexData create() {
return new ISOMVertexData();
}});
private int maxEpoch;
private int epoch;
private int radiusConstantTime;
private int radius;
private int minRadius;
private double adaption;
private double initialAdaption;
private double minAdaption;
protected GraphElementAccessor<V,E> elementAccessor =
new RadiusGraphElementAccessor<V,E>();
private double coolingFactor;
private List<V> queue = new ArrayList<V>();
private String status = null;
/**
* Returns the current number of epochs and execution status, as a string.
*/
public String getStatus() {
return status;
}
public ISOMLayout(Graph<V,E> g) {
super(g);
}
public void initialize() {
setInitializer(new RandomLocationTransformer<V>(getSize()));
maxEpoch = 2000;
epoch = 1;
radiusConstantTime = 100;
radius = 5;
minRadius = 1;
initialAdaption = 90.0D / 100.0D;
adaption = initialAdaption;
minAdaption = 0;
//factor = 0; //Will be set later on
coolingFactor = 2;
//temperature = 0.03;
//initialJumpRadius = 100;
//jumpRadius = initialJumpRadius;
//delay = 100;
}
/**
* Advances the current positions of the graph elements.
*/
public void step() {
status = "epoch: " + epoch + "; ";
if (epoch < maxEpoch) {
adjust();
updateParameters();
status += " status: running";
} else {
status += "adaption: " + adaption + "; ";
status += "status: done";
// done = true;
}
}
ISOMVertexData tempISOM;
Point3f tempXYD;
private synchronized void adjust() {
//Generate random position in graph space
tempISOM = new ISOMVertexData();
tempXYD = new Point3f();
// creates a new XYZ data location
tempXYD.set((float)(10 + Math.random() * getSize().getRadius()),
(float)(10 + Math.random() * getSize().getRadius()),
(float)(10 + Math.random() * getSize().getRadius()));
//Get closest vertex to random position
V winner = elementAccessor.getVertex(this, tempXYD);
while(true) {
try {
for(V v : getGraph().getVertices()) {
ISOMVertexData ivd = getISOMVertexData(v);
ivd.distance = 0;
ivd.visited = false;
}
break;
} catch(ConcurrentModificationException cme) {}
}
adjustVertex(winner);
}
private synchronized void updateParameters() {
epoch++;
double factor = Math.exp(-1 * coolingFactor * (1.0 * epoch / maxEpoch));
adaption = Math.max(minAdaption, factor * initialAdaption);
//jumpRadius = (int) factor * jumpRadius;
//temperature = factor * temperature;
if ((radius > minRadius) && (epoch % radiusConstantTime == 0)) {
radius--;
}
}
private synchronized void adjustVertex(V v) {
queue.clear();
ISOMVertexData ivd = getISOMVertexData(v);
ivd.distance = 0;
ivd.visited = true;
queue.add(v);
V current;
while (!queue.isEmpty()) {
current = queue.remove(0);
ISOMVertexData currData = getISOMVertexData(current);
Point3f currXYData = transform(current);
double dx = tempXYD.getX() - currXYData.getX();
double dy = tempXYD.getY() - currXYData.getY();
double dz = tempXYD.getZ() - currXYData.getZ();
double factor = adaption / Math.pow(2, currData.distance);
currXYData.set((float)(currXYData.getX()+(factor*dx)),
(float)(currXYData.getY()+(factor*dy)),
(float)(currXYData.getZ()+(factor*dz)));
// currXYData.addX(factor * dx);
// currXYData.addY(factor * dy);
if (currData.distance < radius) {
Collection<V> s = getGraph().getNeighbors(current);
//current.getNeighbors();
while(true) {
try {
for(V child : s) {
// for (Iterator iter = s.iterator(); iter.hasNext();) {
// Vertex child = (Vertex) iter.next();
ISOMVertexData childData = getISOMVertexData(child);
if (childData != null && !childData.visited) {
childData.visited = true;
childData.distance = currData.distance + 1;
queue.add(child);
}
}
break;
} catch(ConcurrentModificationException cme) {}
}
}
}
}
public ISOMVertexData getISOMVertexData(V v) {
return isomVertexData.get(v);
}
/**
* This one is an incremental visualization.
* @return <code>true</code> is the layout algorithm is incremental, <code>false</code> otherwise
*/
public boolean isIncremental() {
return true;
}
/**
* For now, we pretend it never finishes.
* @return <code>true</code> is the increments are done, <code>false</code> otherwise
*/
public boolean done() {
return epoch >= maxEpoch;
}
public static class ISOMVertexData {
public Vector3f disp;
int distance;
boolean visited;
public ISOMVertexData() {
initialize();
}
public void initialize() {
disp = new Vector3f();
distance = 0;
visited = false;
}
public double getXDisp() {
return disp.getX();
}
public double getYDisp() {
return disp.getY();
}
public double getZDisp() {
return disp.getZ();
}
public void setDisp(double x, double y, double z) {
disp.set((float)x, (float)y, (float)z);
// disp.set(1, y);
}
public void incrementDisp(double x, double y, double z) {
disp.add(new Vector3f((float)x, (float)y, (float)z));
// disp.set(1, disp.get(1) + y);
}
public void decrementDisp(double x, double y, double z) {
disp.sub(new Vector3f((float)x, (float)y, (float)z));
// disp.set(1, disp.get(1) - y);
}
}
public void reset() {
epoch = 0;
}
}