timeBench.action.layout.GROOVELayout Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of timebench Show documentation
TimeBench, a flexible, easy-to-use, and reusable software library written in Java that provides foundational data structures and algorithms for time- oriented data in Visual Analytics.
The newest version!
package timeBench.action.layout;

import ieg.prefuse.data.DataHelper;

import java.awt.Color;
import java.awt.Point;
import java.awt.Rectangle;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.TreeMap;

import org.apache.commons.lang3.tuple.Pair;
import org.timebench.util.color.HCL;

import prefuse.Display;
import prefuse.data.Graph;
import prefuse.data.Node;
import prefuse.data.Schema;
import prefuse.data.Tree;
import prefuse.data.Tuple;
import prefuse.util.ColorLib;
import prefuse.util.PrefuseLib;
import prefuse.visual.NodeItem;
import prefuse.visual.VisualGraph;
import prefuse.visual.VisualItem;
import prefuse.visual.VisualTable;
import prefuse.visual.VisualTree;
import timeBench.calendar.Calendar;
import timeBench.calendar.CalendarFactory;
import timeBench.calendar.CalendarManager;
import timeBench.calendar.Granule;
import timeBench.data.GranularityAggregationTreeProvider;
import timeBench.data.TemporalDataException;
import timeBench.data.TemporalObject;

/**
 * 
 * 
 * 
 * Added:          / TL

 * Modifications: 
 * 
 * 
 * @author Tim Lammarsch
 *
 */
public class GROOVELayout extends prefuse.action.layout.Layout {
	
	int[] hotPalette;
	String group = "GROOVE";
	GranularityAggregationTreeProvider dataProvider;
	GranularityGROOVELayoutSettings[] settings;
	String labelGroup = "GROOVELabels";
	int hDepth = 0;
	int vDepth = 0;
	double minLuminance = HCL.getMinLuminanceForChroma(60, 2.2);
	double maxLuminance = HCL.getMaxLuminanceForChroma(60, 2.2);

	public static final int ORIENTATION_HORIZONTAL = 0;
	public static final int ORIENTATION_VERTICAL = 1;
	public static final int COLOR_CALCULATION_GLOWING_METAL = 0;
	public static final int COLOR_CALCULATION_H_BLUE_RED = 1;
	public static final int COLOR_CALCULATION_L = 2;
	public static final int FITTING_FULL_AVAILABLE_SPACE = 0;
	public static final int FITTING_DEPENDING_ON_POSSIBLE_VALUES = 1;
	
	public GROOVELayout(String group,String labelGroup,GranularityAggregationTreeProvider dataProvider,
			int columnUsed,GranularityGROOVELayoutSettings[] settings) {		
		hotPalette = prefuse.util.ColorLib.getHotPalette(768);
		this.group = group;
		this.labelGroup = labelGroup;
		this.dataProvider = dataProvider;
		this.settings = settings;
		
		for(int i=1; i relativeSize = new ArrayList();
            ArrayList minIdentifiers = new ArrayList();
            ArrayList maxIdentifiers = new ArrayList();
            buildSizeChart(dataProvider.getGranularityAggregationTree().roots().iterator().next(),
                    relativeSize,minIdentifiers,maxIdentifiers,0);
            
			layoutGranularity(vg,vgl,vgl.getRoot().getChild(0),vgl.getRoot().getChild(1),
			        (NodeItem)m_vis.getVisualItem(group, dataProvider.getGranularityAggregationTree().roots().iterator().next()),
					position,0,minIdentifiers,maxIdentifiers);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	private void buildSizeChart(TemporalObject node, ArrayList relativeSize, ArrayList minIdentifiers, ArrayList maxIdentifiers, int level) throws TemporalDataException {
	    // TODO relativeSize is never read
		if(relativeSize.size() <= level)
			relativeSize.add(0f);
		if(minIdentifiers.size() <= level)
			minIdentifiers.add(Long.MAX_VALUE);
		if(maxIdentifiers.size() <= level)
			maxIdentifiers.add(Long.MIN_VALUE);
		if (settings[level].getFitting() == FITTING_DEPENDING_ON_POSSIBLE_VALUES) {
			minIdentifiers.set(level,node.getTemporalElement().getGranule().getGranularity().getMinGranuleIdentifier());
			maxIdentifiers.set(level,node.getTemporalElement().getGranule().getGranularity().getMaxGranuleIdentifier());
		} else {
			minIdentifiers.set(level, Math.min(minIdentifiers.get(level), node.getTemporalElement().getGranule().getIdentifier()));
			maxIdentifiers.set(level, Math.max(maxIdentifiers.get(level), node.getTemporalElement().getGranule().getIdentifier()));
		}		
		if(node.getChildCount() == 0)
			relativeSize.add(1f);
		else {
			for(TemporalObject o : node.childObjects()) {
				buildSizeChart(o,relativeSize,minIdentifiers,maxIdentifiers,level+1);
			}
			//settings[level]
		}
	}
	
	/**
	 * @param vgl 
	 * @throws Exception 
	 * 
	 */
	private void layoutGranularity(VisualGraph vg,VisualTree vgl, Node hNode,Node vNode, NodeItem node,Rectangle position,int granularityLevel,ArrayList minIdentifiers,ArrayList maxIdentifiers) throws Exception {		

		if(granularityLevel > 0) {
			position.x += settings[granularityLevel-1].getBorderWith()[0];
			position.y += settings[granularityLevel-1].getBorderWith()[1];
			position.width -= (settings[granularityLevel-1].getBorderWith()[0]+settings[granularityLevel].getBorderWith()[2]);
			position.height -= (settings[granularityLevel-1].getBorderWith()[1]+settings[granularityLevel].getBorderWith()[3]);
		}
		
		node.setX(position.getCenterX());
		node.setY(position.getCenterY());
		node.setSizeX(position.getWidth());
		node.setSizeY(position.getHeight());
		node.setDOI(granularityLevel);
		node.setStrokeColor(ColorLib.rgba(0, 0, 0, 0));			
		
		if(granularityLevel + 1 < settings.length) {
			Iterator iChilds = node.inNeighbors();
			while(iChilds.hasNext()) {
				NodeItem iChild = iChilds.next();				
				Granule granule = ((TemporalObject)iChild.getSourceTuple()).getTemporalElement().getGranule();
				int numberOfSubElements = (int)(maxIdentifiers.get(granularityLevel+1)-minIdentifiers.get(granularityLevel+1)+1);
				Rectangle subPosition = (Rectangle)position.clone();
				Node hTargetNode = null;
				Node vTargetNode = null;
				Node targetNode = null;
				if (settings[granularityLevel+1].getOrientation() == ORIENTATION_HORIZONTAL) {
					subPosition.x += position.width/numberOfSubElements*(granule.getIdentifier()-minIdentifiers.get(granularityLevel+1));
					subPosition.width = position.width/numberOfSubElements;
					for(int i=0; i