VisClient/org/hfbk/vis/visnode/VisSet.java

Go to the documentation of this file.

package org.hfbk.vis.visnode;

import java.awt.AWTEvent;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.dronus.gl.GLTextPanel;
import org.dronus.gl.GLUtil;
import org.dronus.graph.Edge;
import org.dronus.graph.ForceEdge;
import org.dronus.graph.Node;
import org.hfbk.vis.Partition;
import org.hfbk.vis.Prefs;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.vector.Vector3f;

public class VisSet extends VisNodeDraggable {

        final float CUTOFF_DISTANCE=30;
        //final float CUTOFF_DISTANCE=10;
        
        final float ATTRACT=.025f;
        
        final float REPELL=20;
        
        class VisEdge{
                VisNode from, to;
                String type;
                
                GLTextPanel  textP;
                
                float force=1;
                
                public VisEdge(VisNode from, VisNode to, String type, float force) {
                        this.from=from;
                        this.to=to;
                        this.type=type;
                        this.force=force;
                        //textP=new GLTextPanel(type,0,0);
                }               
                
                public boolean equals(Object obj) {
                        return (obj instanceof VisEdge
                                        && ((VisEdge)obj).from==from
                                        && ((VisEdge)obj).to  ==to
                        );
                }
                public int hashCode() { return from.hashCode()^to.hashCode();   }
                
                void renderSelf() {
                        Vector3f p1=new Vector3f(from.position);
                        Vector3f p2=new Vector3f(  to.position);
                        
                        GL11.glBegin(GL11.GL_LINES);
                        GL11.glColor3f(1,1,1);
                        GL11.glVertex3f(p1.x,p1.y,p1.z);
                        //GL11.glColor3f(.2f,1,.5f);
                        GL11.glColor4f(1,1,1,.5f);
                        GL11.glVertex3f(p2.x,p2.y,p2.z);
                        GL11.glEnd();
                        
                        p1.scale(.5f); p2.scale(.5f);
                        Vector3f mid=Vector3f.add(p1,p2,null);
        
                        if (textP!=null){
                                GL11.glPushMatrix();
                                GL11.glTranslatef(mid.x,mid.y,mid.z);
                                GLUtil.alignDirection(Vector3f.sub(from.position,to.position,null));
                
                                textP.render();
                                GL11.glDisable(GL11.GL_TEXTURE_2D);
                                GL11.glPopMatrix();
                        }
                }
        }
        
        HashMap<Edge,VisEdge> edges=new HashMap<Edge,VisEdge>(); 
        
        VisNode create(Node node, Vector3f pos){
                return new VisKeyword(new Node(node.text+" ("+node.type+")"), pos);
        }
        
        public VisSet(Node set, Vector3f pos) {
                super(set, pos);

                if (set!=null) {
                        update(set);
                        //dirty: remove edges to prevent the graph parser from 
                        //visualizing nodes that are part of this set
                        set.getEdges().clear();
                }
        }

        HashMap<Node, VisNode> nodes=new HashMap<Node,VisNode>();

        public void update(Node set){
                //build visible nodes
                for(Node n: set.getFromNodes())                 
                        if(!nodes.containsKey(n) && !n.type.equals("Set")){ //filter out subsets                                
                                float x=(float)Math.random()*100, y=(float)Math.random()*10, z=(float)Math.random()*100;
                                VisNode vn=create(n, new Vector3f(x,y,z));
                                add(vn);
                                nodes.put(n,vn);
                                layoutLocked=false;
                        }
                        
                //build visible edges. as every edge is refered by two nodes,
                //we use a HashSet <i>edges</i> to filter out the doubles.  
                for (Node n: nodes.keySet())
                        for (Edge e: n.getEdges())
                                if (!edges.containsKey(e)){                             
                                        VisNode from=nodes.get(e.getFrom()), to=nodes.get(e.getTo());
                                        if(from!=null && to!=null){ //root set and subset edges have no VisNodes
                                                float force=1;
                                                if (e instanceof ForceEdge)
                                                        force=((ForceEdge)e).force;
                                                edges.put(e, new VisEdge(from, to, e.type, force));
                                                layoutLocked=false;
                                        }
                                }
        }

        Vector3f tmp=new Vector3f();
        void repell(DeltaVector3f p1, DeltaVector3f p2){
                
                Vector3f.sub(p2.old, p1.old, tmp); //relative position
                if (tmp.x>CUTOFF_DISTANCE || tmp.x<-CUTOFF_DISTANCE ||   //early cutoff if far away  
                        tmp.y>CUTOFF_DISTANCE || tmp.y<-CUTOFF_DISTANCE ||
                        tmp.z>CUTOFF_DISTANCE || tmp.z<-CUTOFF_DISTANCE ) return;
                
                
                //float l=tmp.lengthSquared(); //square of distance
                float l=tmp.length(); //square of distance
                
                l=Math.max(1,l); //prevent desasters on singularities (nodes on same position)
                
                tmp.scale(REPELL/l/l/l); //force computed as relative postition divided by 
                
                Vector3f.add(p2, tmp, p2); //move both nodes away from
                Vector3f.sub(p1, tmp, p1); //their common center
        }
        
        public void render(List<AWTEvent> events) {
                GL11.glDisable(GL11.GL_TEXTURE_2D);
                super.render(events);
        }
        
        
        class DeltaVector3f extends Vector3f{
                public DeltaVector3f(Vector3f v) {
                        super(v);
                        old=new Vector3f(v);
                }
                Vector3f old; 
        }
        
        void layout(){
                
                int checks=0; //stats

                
                for(VisNode n : children){
                        n.position=new DeltaVector3f(n.position);
                        //n.position.y*=.998f;  
                        //n.position.scale(.999f);                      
                        n.position.y*=.9998f;  
                        n.position.scale(.9999f);
                }
                
                //build space partition of children
                Partition part=new Partition(children, CUTOFF_DISTANCE);

                //do repellant forces
                for (Map.Entry<Partition.Triple,List<VisNode>>  entry: part.entrySet()){ //all cells in the partition
                        Partition.Triple triple=entry.getKey();
                        List<VisNode>cell=entry.getValue();                     
                        
                        //each node pair in this cell
                        int n=cell.size();                      
                        for(int i=0; i<n; i++){                         
                                VisNode n1=cell.get(i);                         
                                for (int j=0; j<i; j++){
                                        VisNode n2=cell.get(j);
                                        repell((DeltaVector3f)n1.position,(DeltaVector3f)n2.position);
                                        checks++;                                       
                                }               
                        }
                        
                        //each node paired with one in the neigbouring cell
                        for (List<VisNode> otherCell: part.getHalfNeighbourhood(triple)){ 
                                if(otherCell==null) continue;
                                for (VisNode n1: cell){                         
                                        for (VisNode n2: otherCell){
                                                repell((DeltaVector3f)n1.position,(DeltaVector3f)n2.position);
                                                checks++;
                                        }               
                                }
                        }
                }
                
                //do attracting spring forces (by edges)
                for (VisEdge e: edges.values()){
                
                        VisNode n1=e.from, n2=e.to;
                        Vector3f.sub(((DeltaVector3f)n2.position).old, ((DeltaVector3f)n1.position).old, tmp);
                        
                        tmp.scale(-ATTRACT*e.force); 
                        Vector3f.add(n2.position, tmp, n2.position); //pull nodes to common center
                        Vector3f.sub(n1.position, tmp, n1.position);                            
                }       

                float maxspeed=0;
//              for (VisNode n: children)                       
        //              maxspeed=Math.max(maxspeed, Vector3f.sub(n.position, ((DeltaVector3f)n.position).old,null).length());
                
                //if (maxspeed<0.05f) layoutLocked=true;
                
                if (Prefs.current.debug) {
                        int n=children.size();
                        System.out.println("#nodes:"+n+" #cells:"+part.size()+" mean #nodes:"+part.getMeanCount()+" #pairs:"+checks+" of "+n*n/2+" speed:"+maxspeed);                   
                }
        }
        
        void renderSelf() {
        
                if (!layoutLocked) layout();
                
                //draw edges.           
                for (VisEdge e: edges.values())
                        e.renderSelf();
        }
        
}

---