protected virtual IATKProperty DrawAttributeFilterEditor(SerializedProperty element, Rect rect)
{
IATKProperty dirtyFlag = IATKProperty.None;
Rect contentRect = rect;
contentRect.height = EditorGUIUtility.singleLineHeight;
Rect copyrect = rect;
copyrect.height -= copyrect.height / 10f;
EditorGUI.BeginChangeCheck();
var attributeProp = element.FindPropertyRelative("Name");
int attributeIndex = Array.IndexOf(dimensions, attributeProp.stringValue);
if (attributeIndex >= 0)
{
attributeIndex = EditorGUI.Popup(contentRect, attributeIndex, dimensions);
attributeProp.stringValue = dimensions[attributeIndex];
if (EditorGUI.EndChangeCheck())
{
dirtyFlag = IATKProperty.DimensionChange;
}
}
EditorGUI.BeginDisabledGroup(attributeIndex < 1);
contentRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
EditorGUI.BeginChangeCheck();
var minFilterProp = element.FindPropertyRelative("MinFilter");
var maxFilterProp = element.FindPropertyRelative("MaxFilter");
DrawMinMaxSlider(contentRect, minFilterProp, maxFilterProp, attributeProp.stringValue, dataSource);
if (EditorGUI.EndChangeCheck())
{
dirtyFlag = IATKProperty.DimensionChange;
}
contentRect.y += EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
EditorGUI.BeginChangeCheck();
var minScaleProp = element.FindPropertyRelative("MinScale");
var maxScaleProp = element.FindPropertyRelative("MaxScale");
DrawMinMaxSlider(contentRect, minScaleProp, maxScaleProp, attributeProp.stringValue, dataSource);
if (EditorGUI.EndChangeCheck())
{
dirtyFlag = IATKProperty.DimensionChange;
}
EditorGUI.EndDisabledGroup();
return(dirtyFlag);
}
private string FindFormulaForProperty(List <VisVar> visVars, IATKProperty property)
{
if (visVars == null)
{
return("");
}
var variables = visVars.Where(x => x.Property == property);
return((variables.Count() > 0) ? variables.First().Formula : "");
}
protected bool InheritFromParent(IATKProperty property, bool breakInheritance)
{
if (inheritanceDictionary[property] && breakInheritance)
{
inheritanceDictionary[property] = false;
}
if (!inheritanceDictionary[property] && !breakInheritance)
{
return(true);
}
return(false);
}
private void UpdateScatterplotProperty(IATKProperty property)
{
switch (property)
{
case IATKProperty.ColourPaletteBy:
targetScatterplot.SetColourPaletteBy(targetScatterplot.ColourPaletteBy);
break;
case IATKProperty.ColourPalette:
targetScatterplot.SetColourPalette(targetScatterplot.ColourPalette);
break;
}
}
private void UpdateBarProperty(IATKProperty property)
{
switch (property)
{
case IATKProperty.NumXBins:
targetBarchart.SetNumXBins(targetBarchart.NumXBins);
break;
case IATKProperty.NumZBins:
targetBarchart.SetNumZBins(targetBarchart.NumZBins);
break;
case IATKProperty.BarAggregation:
targetBarchart.SetBarAggregation(targetBarchart.BarAggregation);
break;
}
}
private void UpdateAxes(IATKProperty property)
{
if (dataAttributes.TryGetValue(property, out DataAttribute dataAttribute) && dataAttribute.DataType != IATKDataType.Translate)
{
if (!dataAxes.TryGetValue(property, out Axis axis))
{
GameObject axisHolder = (GameObject)Instantiate(Resources.Load("NewerAxis"));
axisHolder.transform.parent = transform;
axisHolder.transform.localPosition = Vector3.zero;
axisHolder.transform.localRotation = Quaternion.identity;
axis = axisHolder.GetComponent <Axis>();
IATKDimension dimension = (property == IATKProperty.X) ? IATKDimension.X : (property == IATKProperty.Y) ? IATKDimension.Y : IATKDimension.Z;
axis.Initialise(this, dataAttribute, dimension);
dataAxes.Add(property, axis);
}
else
{
axis.UpdateAttribute(dataAttribute);
}
if (property == IATKProperty.X)
{
axis.UpdateLength(geometry.transform.localScale.x);
}
else if (property == IATKProperty.Y)
{
axis.UpdateLength(geometry.transform.localScale.y);
}
else if (property == IATKProperty.Z)
{
axis.UpdateLength(geometry.transform.localScale.z);
}
}
else
{
if (dataAxes.TryGetValue(property, out Axis axis))
{
Destroy(axis.gameObject);
dataAxes.Remove(property);
}
}
}
private void AbstractVisualisationUpdated(AbstractVisualisation aVis, IATKProperty property)
{
// When any visualisation is updated, check to see which schema it might be corresponding to
foreach (var schema in Schemas)
{
if (schema.InitialState.XDimension.Name == aVis.XDimension.Name &&
schema.InitialState.YDimension.Name == aVis.YDimension.Name &&
schema.InitialState.ZDimension.Name == aVis.ZDimension.Name
)
{
if (!Transitions.Select(x => x.TargetVisualisation).Contains(aVis))
{
ActiveTransition transition = new ActiveTransition(schema, aVis);
transition.TweenUpdated.AddListener(TweenUpdated);
Transitions.Add(transition);
}
}
}
}
private void UpdateVisualisationProperty(IATKProperty property)
{
switch (property)
{
case IATKProperty.X:
targetVisualisation.SetXDimension(targetVisualisation.XDimension);
break;
case IATKProperty.Y:
targetVisualisation.SetYDimension(targetVisualisation.YDimension);
break;
case IATKProperty.Z:
targetVisualisation.SetZDimension(targetVisualisation.ZDimension);
break;
case IATKProperty.Colour:
targetVisualisation.SetColour(targetVisualisation.Colour);
break;
case IATKProperty.ColourBy:
targetVisualisation.SetColourBy(targetVisualisation.ColourBy);
break;
case IATKProperty.ColourGradient:
targetVisualisation.SetColourGradient(targetVisualisation.ColourGradient);
break;
case IATKProperty.Size:
targetVisualisation.SetSize(targetVisualisation.Size);
break;
case IATKProperty.SizeBy:
targetVisualisation.SetSizeBy(targetVisualisation.SizeBy);
break;
case IATKProperty.Scale:
targetVisualisation.SetScale(targetVisualisation.Scale);
break;
}
}
protected void OnAbstractVisualisationUpdated(IATKProperty property)
{
AbstractVisualisationUpdated.Invoke(this, property);
}
public abstract void UpdateView(IATKProperty property);
public override void UpdateView(IATKProperty property)
{
if (!isInitialised)
{
return;
}
if (View == null)
{
return;
}
switch (property)
{
case IATKProperty.X:
if (XDimension.Name == "Undefined")
{
View.SetVertices(new float[DataSource.DataCount], IATKDimension.X);
DestroyAxis(IATKDimension.X);
}
else
{
float[] xPositions = SetBinnedDataDimension(DataSource[XDimension.Name].Data, NumXBins, IsDimensionCategorical(XDimension.Name));
View.SetVertices(xPositions, IATKDimension.X);
if (XAxis == null)
{
CreateAxis(IATKDimension.X);
}
else
{
UpdateAxisDimensionAndRanges(IATKDimension.X);
}
}
UpdateView(IATKProperty.Y);
break;
case IATKProperty.Y:
float[] yPositions;
if (YDimension.Name == "Undefined")
{
yPositions = SetAggregatedDimension(null, IATKBarAggregation.Count);
}
// If the aggregation type is not set, just use the raw position
else if (BarAggregation == IATKBarAggregation.None)
{
yPositions = DataSource[YDimension.Name].Data;
// Override the array such that all bars are shown
float[] oneArray = new float[DataSource.DataCount];
for (int i = 0; i < DataSource.DataCount; i++)
{
oneArray[i] = 1;
}
View.SetUVs(oneArray, IATKDimension.Y);
}
else
{
yPositions = SetAggregatedDimension(DataSource[YDimension.Name].Data, BarAggregation);
}
View.SetVertices(yPositions, IATKDimension.Y);
UpdateView(IATKProperty.Size);
break;
case IATKProperty.Z:
if (ZDimension.Name == "Undefined")
{
View.SetVertices(new float[DataSource.DataCount], IATKDimension.Z);
DestroyAxis(IATKDimension.Z);
}
else
{
float[] zPositions = SetBinnedDataDimension(DataSource[ZDimension.Name].Data, NumZBins, IsDimensionCategorical(ZDimension.Name));
View.SetVertices(zPositions, IATKDimension.Z);
if (ZAxis == null)
{
CreateAxis(IATKDimension.Z);
}
else
{
UpdateAxisDimensionAndRanges(IATKDimension.Z);
}
}
UpdateView(IATKProperty.Y);
break;
case IATKProperty.Size:
float xBins = NumXBins;
float zBins = NumZBins;
if (XDimension.Name != "Undefined" && IsDimensionCategorical(XDimension.Name))
{
xBins = DataSource[XDimension.Name].Data.Distinct().Count();
}
if (ZDimension.Name != "Undefined" && IsDimensionCategorical(ZDimension.Name))
{
zBins = DataSource[ZDimension.Name].Data.Distinct().Count();
}
if (XDimension.Name == "Undefined")
{
View.SetFloatProperty("_Width", 0.005f);
}
else
{
View.SetFloatProperty("_Width", 1 / xBins / 2f);
}
if (ZDimension.Name == "Undefined")
{
View.SetFloatProperty("_Depth", 0.005f);
}
else
{
View.SetFloatProperty("_Depth", 1 / zBins / 2f);
}
break;
case IATKProperty.Colour:
if (ColourBy == "Undefined")
{
View.SetColour(Colour);
}
break;
}
}
public override void UpdateView(IATKProperty property)
{
if (!isInitialised || View == null)
{
CreateView(VisualisationReference);
}
switch (property)
{
case IATKProperty.X:
case IATKProperty.Y:
case IATKProperty.Z:
if (!queuedPropertyUpdates.Contains(property))
{
queuedPropertyUpdates.Add(property);
}
arePropertiesQueued = true;
break;
case IATKProperty.Colour:
if (ColourBy == "Undefined")
{
View.SetColour(Colour);
}
break;
case IATKProperty.ColourBy:
case IATKProperty.ColourGradient:
if (ColourBy != "Undefined")
{
View.SetColours(MapColoursContinuous(DataSource[ColourBy].Data));
}
else
{
UpdateView(IATKProperty.Colour);
}
break;
case IATKProperty.Size:
View.SetUVs(Size, IATKDimension.Y);
break;
case IATKProperty.SizeBy:
if (SizeBy != "Undefined")
{
View.SetUVs(DataSource[SizeBy].Data, IATKDimension.Y);
}
else
{
UpdateView(IATKProperty.Size);
}
break;
case IATKProperty.Scale:
UpdateAxisLength(IATKDimension.X);
UpdateAxisLength(IATKDimension.Y);
UpdateAxisLength(IATKDimension.Z);
View.transform.localScale = Scale;
break;
case IATKProperty.ColourPalette:
if (ColourPaletteBy != "Undefined")
{
View.SetColours(MapColoursPalette(DataSource[ColourPaletteBy].Data));
}
else
{
UpdateView(IATKProperty.Colour);
}
break;
}
OnAbstractVisualisationUpdated(property);
}
public override void UpdateView(IATKProperty property)
{
if (!isInitialised)
{
return;
}
if (EdgeView == null || View == null)
{
if (CheckEdgeDimensions() && CheckNodeDimensions())
{
CreateView(VisualisationReference);
}
return;
}
switch (property)
{
case IATKProperty.X:
if (XDimension.Name == "Undefined")
{
float[] zeroArray = new float[nodeLength];
EdgeView.SetVertices(zeroArray, IATKDimension.X);
View.SetVertices(zeroArray, IATKDimension.X);
DestroyAxis(IATKDimension.X);
}
else
{
EdgeView.SetVertices(DataSource[XDimension.Name].Data, IATKDimension.X);
View.SetVertices(DataSource[XDimension.Name].Data, IATKDimension.X);
if (XAxis == null)
{
CreateAxis(IATKDimension.X);
}
else
{
UpdateAxisDimensionAndRanges(IATKDimension.X);
}
View.SetFloatProperty("_MinNormX", XDimension.MinScale);
View.SetFloatProperty("_MaxNormX", XDimension.MaxScale);
View.SetFloatProperty("_MinX", XDimension.MinFilter);
View.SetFloatProperty("_MaxX", XDimension.MaxFilter);
}
break;
case IATKProperty.Y:
if (YDimension.Name == "Undefined")
{
float[] zeroArray = new float[nodeLength];
EdgeView.SetVertices(zeroArray, IATKDimension.Y);
View.SetVertices(zeroArray, IATKDimension.Y);
DestroyAxis(IATKDimension.Y);
}
else
{
EdgeView.SetVertices(DataSource[YDimension.Name].Data, IATKDimension.Y);
View.SetVertices(DataSource[YDimension.Name].Data, IATKDimension.Y);
if (YAxis == null)
{
CreateAxis(IATKDimension.Y);
}
else
{
UpdateAxisDimensionAndRanges(IATKDimension.Y);
}
View.SetFloatProperty("_MinNormY", YDimension.MinScale);
View.SetFloatProperty("_MaxNormY", YDimension.MaxScale);
View.SetFloatProperty("_MinY", YDimension.MinFilter);
View.SetFloatProperty("_MaxY", YDimension.MaxFilter);
}
break;
case IATKProperty.Z:
if (ZDimension.Name == "Undefined")
{
float[] zeroArray = new float[nodeLength];
EdgeView.SetVertices(zeroArray, IATKDimension.Z);
View.SetVertices(zeroArray, IATKDimension.Z);
DestroyAxis(IATKDimension.Z);
}
else
{
EdgeView.SetVertices(DataSource[ZDimension.Name].Data, IATKDimension.Z);
View.SetVertices(DataSource[ZDimension.Name].Data, IATKDimension.Z);
if (ZAxis == null)
{
CreateAxis(IATKDimension.Z);
}
else
{
UpdateAxisDimensionAndRanges(IATKDimension.Z);
}
View.SetFloatProperty("_MinNormZ", ZDimension.MinScale);
View.SetFloatProperty("_MaxNormZ", ZDimension.MaxScale);
View.SetFloatProperty("_MinZ", ZDimension.MinFilter);
View.SetFloatProperty("_MaxZ", ZDimension.MaxFilter);
}
break;
case IATKProperty.Colour:
if (ColourBy == "Undefined")
{
View.SetColour(Colour);
EdgeView.SetColour(Colour);
}
break;
case IATKProperty.ColourBy:
case IATKProperty.ColourGradient:
if (ColourBy != "Undefined")
{
Color[] colours = MapColoursContinuous(DataSource[ColourBy].Data);
View.SetColours(colours);
EdgeView.SetColours(colours);
}
else
{
UpdateView(IATKProperty.Colour);
}
break;
case IATKProperty.Size:
View.SetUVs(Size, IATKDimension.Y);
EdgeView.SetUVs(Size, IATKDimension.Y);
break;
case IATKProperty.SizeBy:
if (SizeBy != "Undefined")
{
View.SetUVs(DataSource[SizeBy].Data, IATKDimension.Y);
EdgeView.SetUVs(DataSource[SizeBy].Data, IATKDimension.Y);
}
else
{
UpdateView(IATKProperty.Size);
}
break;
case IATKProperty.Scale:
UpdateAxisLength(IATKDimension.X);
UpdateAxisLength(IATKDimension.Y);
UpdateAxisLength(IATKDimension.Z);
View.transform.localScale = Scale;
EdgeView.transform.localScale = Scale;
break;
}
}
