private List <NodeRenderer> GetChildNodeRenderers(NodeRenderer parentNode)
{
List <NodeRenderer> result = new List <NodeRenderer>();
foreach (IDescriptorProxy descriptor in parentNode.Node.Descriptors.Where(d => d.DescriptorType.Name == "To" &&
d.Relationship.RelationshipType.Name != "MapContainerRelationship"))
{
if (descriptor.Relationship.RelationshipType.Name == "TransclusionRelationship")
{
IDescriptorProxy transMapDescriptor = descriptor.Relationship.Descriptors.Where(d => d.DescriptorType.Name == "TransclusionMap").First();
if (transMapDescriptor.NodeId != this.Navigator.FocalNodeId ||
descriptor.Relationship.Descriptors.Where(d => d.DescriptorType.Name == "From").Count() == 0)
{
continue;
}
}
IDescriptorProxy fromDescriptor = descriptor.Relationship.Descriptors.Where(d => d.DescriptorType.Name == "From").First();
if (this.ViewManager.CurrentView.NodeRenderers.ContainsKey(fromDescriptor.NodeId))
{
NodeRenderer childNodeRenderer = this.ViewManager.CurrentView.NodeRenderers[fromDescriptor.NodeId];
result.Add(childNodeRenderer);
}
}
return(result);
}
private void RenderTODOList()
{
float TOP_PANEL_MARGING = 40;
if (TCore.size == TODOListSize.SMALL)
{
TOP_PANEL_MARGING = 25;
}
int i = 1;
GUILayout.BeginArea(new Rect(0, TOP_PANEL_MARGING + 2, TAGS_PANLE_WIDTH, position.height - TOP_PANEL_MARGING), ""); {
foreach (TagTemplate tpl in tags)
{
TagRenderer.renderTag(tpl, i);
i++;
}
} GUILayout.EndArea();
GUILayout.BeginArea(new Rect(TAGS_PANLE_WIDTH, TOP_PANEL_MARGING + 2, position.width - TAGS_PANLE_WIDTH, position.height - TOP_PANEL_MARGING), ""); {
scrollPos = EditorGUILayout.BeginScrollView(scrollPos, GUILayout.Width(position.width - TAGS_PANLE_WIDTH), GUILayout.Height(position.height - TOP_PANEL_MARGING));
GUILayout.Box("", GUIStyle.none, new GUILayoutOption[] { GUILayout.ExpandWidth(true), GUILayout.Height(maxYPos) });
i = 1;
Rect DrawArea = position;
DrawArea.width -= TAGS_PANLE_WIDTH;
foreach (TNode node in TCore.nodes)
{
if (!selectedTagName.Equals(string.Empty))
{
if (node.tag != selectedTagName)
{
continue;
}
}
if (search != string.Empty)
{
if (node.text.ToLower().Contains(search.ToLower()))
{
NodeRenderer.renderNode(node, i, DrawArea);
i++;
}
}
else
{
NodeRenderer.renderNode(node, i, DrawArea);
i++;
}
}
maxYPos = (i - 1) * NODE_HEIGHT + 20;
EditorGUILayout.EndScrollView();
} GUILayout.EndArea();
}
void SetupTextLabel(GameObject nodeObject, NodeRenderer target)
{
GameObject textLabel = new GameObject("text");
Text text = textLabel.AddComponent <Text>() as Text;
textLabel.transform.SetParent(target.parent.transform);
text.rectTransform.position = target.nodeImage.rectTransform.position;
text.font = Resources.GetBuiltinResource <Font>("Arial.ttf");
text.text = "x";
target.text = text;
text.alignment = TextAnchor.MiddleCenter;
}
private void LoadStyles()
{
if (_stylesLoaded)
{
return;
}
GUIStyle s = new GUIStyle(GUI.skin.label);
s.normal.textColor = Color.white;
styles.Add(StyledElement.Label, s);
s = new GUIStyle(GUI.skin.label);
s.normal.textColor = Color.white;
s.fontSize = 21;
s.alignment = TextAnchor.MiddleCenter;
styles.Add(StyledElement.StateNode, s);
s = new GUIStyle(GUI.skin.button);
//s.normal.background = CreateBackgroundTexture(new Color32(62, 62, 62, 255));
s.normal.textColor = Color.white;
styles.Add(StyledElement.Button, s);
s = new GUIStyle(GUI.skin.textArea);
s.normal.background = CreateBackgroundTexture(new Color32(81, 84, 90, 255));
s.normal.textColor = Color.white;
styles.Add(StyledElement.TextArea, s);
styles.Add(StyledElement.TextField, s);
s = new GUIStyle(GUI.skin.window);
//s.normal.background = CreateBackgroundTexture(new Color32(255, 255, 0, 255));
s.normal.textColor = Color.white;
styles.Add(StyledElement.Window, s);
s = new GUIStyle(EditorStyles.objectField);
styles.Add(StyledElement.ObjectFieldOriginal, s);
s.normal.textColor = Color.white;
s.normal.background = CreateBackgroundTexture(new Color32(72, 72, 72, 255));
styles.Add(StyledElement.ObjectField, s);
s = new GUIStyle(EditorStyles.toggle);
s.normal.background = CreateBackgroundTexture(new Color32(81, 84, 90, 255));
s.normal.textColor = Color.white;
styles.Add(StyledElement.CheckBox, s);
s = new GUIStyle(GUI.skin.box);
s.normal.background = CreateBackgroundTexture(new Color32(40, 42, 44, 160));
s.normal.textColor = Color.white;
styles.Add(StyledElement.Box, s);
nodeRenderer = new NodeRenderer(styles);
_stylesLoaded = true;
}
private TreeNodeGroup BuildTreeNodeGroup(NodeRenderer leftMostNode)
{
TreeNodeGroup nodeGroup = new TreeNodeGroup();
nodeGroup.ParentNode = leftMostNode;
nodeGroup.ChildNodes = GetChildNodeRenderers(leftMostNode);
nodeGroup.ChildNodes.Sort(new Comparison<NodeRenderer>(NodePositionComparison));
nodeGroup.ParentChildGroups = new List<TreeNodeGroup>();
foreach (NodeRenderer nodeRenderer in nodeGroup.ChildNodes)
{
TreeNodeGroup childGroup = BuildTreeNodeGroup(nodeRenderer);
nodeGroup.ParentChildGroups.Add(childGroup);
}
return nodeGroup;
}
private TreeNodeGroup BuildTreeNodeGroup(NodeRenderer leftMostNode)
{
TreeNodeGroup nodeGroup = new TreeNodeGroup();
nodeGroup.ParentNode = leftMostNode;
nodeGroup.ChildNodes = GetChildNodeRenderers(leftMostNode);
nodeGroup.ChildNodes.Sort(new Comparison <NodeRenderer>(NodePositionComparison));
nodeGroup.ParentChildGroups = new List <TreeNodeGroup>();
foreach (NodeRenderer nodeRenderer in nodeGroup.ChildNodes)
{
TreeNodeGroup childGroup = BuildTreeNodeGroup(nodeRenderer);
nodeGroup.ParentChildGroups.Add(childGroup);
}
return(nodeGroup);
}
private void HandleReplayingLastNodeEvent(Event receivedEvent)
{
if (ViewManager != null && ViewManager.CurrentView != null && ViewManager.CurrentView.NodeRenderers != null &&
receivedEvent.EventArgs != null && receivedEvent.EventArgs.ContainsKey("NodeId"))
{
Guid nodeId = Guid.Empty;
if (Guid.TryParse(receivedEvent.EventArgs["NodeId"], out nodeId))
{
NodeRenderer playingNode = ViewManager.CurrentView.NodeRenderers[nodeId];
{
playingNode.SetIsPlaying(true);
playingNode.ResetMediaIcon(true);
}
}
}
}
public Bitmap RenderTree(DecisionTree tree, Size blockSize)
{
var descendents = tree.Root.Descendents;
var numberOfLeaves = descendents.Count(item => item.IsLeaf);
var depth = tree.Root.Descendents.Max(item => item.Depth);
var offset = new Size(50, 50);
if (numberOfLeaves > 20)
{
tree.Options.MaxNumberOfTerminalNodes = 20;
tree.Prune();
descendents = tree.Root.Descendents;
numberOfLeaves = descendents.Count(item => item.IsLeaf);
depth = tree.Root.Descendents.Max(item => item.Depth);
}
var width = ((2 * blockSize.Width) * numberOfLeaves) + 2 * (offset.Width);
var height = ((blockSize.Height + 100) * (depth + 1)) + 2 * (offset.Height);
blockSize.Height = blockSize.Height + 100;
NodeRenderer nr = new NodeRenderer(blockSize, offset);
Bitmap bitmap = new Bitmap(width, height);
Graphics graphics = Graphics.FromImage(bitmap);
graphics.FillRectangle(Brushes.White, 0, 0, width, height);
var coordinates = GetCoordinates(tree.Root);
foreach (var coordinate in coordinates)
{
var node = coordinate.Key;
nr.RenderNode(graphics, coordinate.Value, node);
if (!node.IsLeaf)
{
foreach (var child in node.Children)
{
nr.RenderEdges(graphics, coordinate.Value, coordinates[child],
string.Format("{0} {1}", DecisionTree.GetStringCondition(child.Condition),
child.ThreshHold));
}
}
}
return(bitmap);
}
/// <summary>
/// Used as the comparison for sorting the nodes based on their initial position.
/// </summary>
/// <param name="node1"></param>
/// <param name="node2"></param>
/// <returns></returns>
private int NodePositionComparison(NodeRenderer node1, NodeRenderer node2)
{
double node1YPosition = (double)node1.GetValue(Canvas.TopProperty);
double node2YPosition = (double)node2.GetValue(Canvas.TopProperty);
if (node1YPosition > node2YPosition)
{
return(1);
}
else if (node1YPosition < node2YPosition)
{
return(-1);
}
else
{
return(0);
}
}
void RenderTreeRecursive(Node node, Vector3 position)
{
Debug.Log($"rendering node: in: {node.inNodes.Count} out: {node.outNode != null}");
NodeRenderer renderer = Instantiate(nodeRendererPrefab, position, Quaternion.identity, transform);
renderer.SetNode(node);
float offset = -node.width * 0.5f;
for (int i = 0; i < node.inNodes.Count; i++)
{
float mainAxisOffset = alignHorizontal ? -nodeWidth : -nodeHeight;
float orthogonalOffset = (offset + node.inNodes[i].width * 0.5f) * (alignHorizontal ? nodeHeight : nodeWidth);
Vector3 childPos = new Vector3(position.x + (alignHorizontal ? mainAxisOffset : orthogonalOffset), position.y + (alignHorizontal ? orthogonalOffset : mainAxisOffset), position.z);
RenderTreeRecursive(node.inNodes[i], childPos);
offset += node.inNodes[i].width;
}
}
// Use this for initialization
void Start()
{
IRenderer <Node> nodeRenderer = new NodeRenderer();
IRepository <Node> nodeRepository = new MemoryRepository <Node> ();
nodeController = new NodeController(nodeRepository, nodeRenderer);
int mockNodes = 997;
for (int i = 0; i + 1 <= mockNodes; i++)
{
Node node = new Node();
node.Position = new Vector3(i * i % 383, i * i % 47, i * i % 173);
nodeController.AddNode(node);
}
nodeController.RenderNodes();
}
private void ToggleParentNodes(bool isSelected, INodeProxy nodeProxy)
{
foreach (Guid parentNodeId in nodeProxy.ParentNodes)
{
if (ParentNavigatorView.ContextNode.Id == parentNodeId)
{
continue; //a map node shouldn't really ever get in this situation where it is transcluded within itself
}
if (ParentNavigatorView.NodeRenderers.ContainsKey(parentNodeId))
{
NodeRenderer nodeRenderer = ParentNavigatorView.NodeRenderers[parentNodeId];
if (!IsParentInCurrentView(nodeProxy, nodeRenderer.Node))
{
continue;
}
nodeRenderer.IsSelected = isSelected;
INodeProxy parentNode = nodeRenderer.Node;
foreach (IDescriptorProxy descriptor in parentNode.Descriptors.GetByDescriptorTypeName("To"))
{
if (descriptor.Relationship.RelationshipType.Name != "MapContainerRelationship" &&
IsParentRelationship(descriptor.Relationship, nodeProxy.Id) &&
ParentNavigatorView.RelationshipRenderers.ContainsKey(descriptor.Relationship.Id))
{
IRelationshipRenderer relationshipRenderer = ParentNavigatorView.RelationshipRenderers[descriptor.Relationship.Id];
relationshipRenderer.IsSelected = isSelected;
}
}
if (isSelected)
{
SelectParentNodes(parentNode);
}
else
{
UnselectParentNodes(parentNode);
}
}
}
}
void DrawLayer(NeuralLayer neuralLayer, List <NodeRenderer> debuggerLayer, ref float leftMargin, float topMargin)
{
float verticalShift = 0;
if (neuralLayer.nodes.Count % 2 == 0)
{
topMargin += 25;
}
for (int i = 0; i < neuralLayer.nodes.Count; i++)
{
GameObject node = new GameObject("node" + i.ToString());
NodeRenderer nodeRenderer = new NodeRenderer(node.AddComponent <Image>() as Image);
nodeRenderer.parent = new GameObject("node" + i.ToString());
NodeDebugger nodeDebugger = nodeRenderer.parent.AddComponent <NodeDebugger>();
nodeDebugger.Init(neuralLayer.nodes[i]);
nodeRenderer.parent.transform.SetParent(targetCanvas.transform);
node.transform.SetParent(nodeRenderer.parent.transform);
nodeRenderer.nodeImage.sprite = nodeTexture;
nodeRenderer.nodeImage.rectTransform.sizeDelta = new Vector2(nodeSize, nodeSize);
float targetCanvasHeight = targetCanvas.gameObject.GetComponent <RectTransform>().rect.height;
float v = i % 2 == 0 ? -verticalShift : verticalShift;
nodeRenderer.nodeImage.rectTransform.position = new Vector2(leftMargin, targetCanvasHeight - topMargin + v);
nodeRenderer.nodeImage.color = new Color32(48, 112, 181, 255);
debuggerLayer.Add(nodeRenderer);
if (i % 2 == 0)
{
verticalShift += 60;
}
SetupTextLabel(node, nodeRenderer);
}
leftMargin += 100;
}
private void ToggleChildNodes(bool isSelected, INodeProxy nodeProxy)
{
foreach (Guid childNodeId in GetAllChildNodes(nodeProxy))
{
if (ParentNavigatorView.NodeRenderers.ContainsKey(childNodeId))
{
NodeRenderer nodeRenderer = ParentNavigatorView.NodeRenderers[childNodeId];
if (nodeProxy.IsTransclusion && !IsChildInCurrentView(nodeProxy, nodeRenderer.Node.Id))
{
continue;
}
nodeRenderer.IsSelected = isSelected;
INodeProxy childNode = nodeRenderer.Node;
foreach (IDescriptorProxy descriptor in childNode.Descriptors.GetByDescriptorTypeName("From"))
{
if (descriptor.Relationship.RelationshipType.Name != "MapContainerRelationship" &&
IsChildRelationship(descriptor.Relationship, nodeProxy.Id) &&
ParentNavigatorView.RelationshipRenderers.ContainsKey(descriptor.Relationship.Id))
{
IRelationshipRenderer relationshipRenderer = ParentNavigatorView.RelationshipRenderers[descriptor.Relationship.Id];
relationshipRenderer.IsSelected = isSelected;
}
}
if (isSelected)
{
SelectChildNodes(childNode);
}
else
{
UnselectChildNodes(childNode);
}
}
}
}
private List<NodeRenderer> GetChildNodeRenderers(NodeRenderer parentNode)
{
List<NodeRenderer> result = new List<NodeRenderer>();
foreach (IDescriptorProxy descriptor in parentNode.Node.Descriptors.Where(d => d.DescriptorType.Name == "To"
&& d.Relationship.RelationshipType.Name != "MapContainerRelationship"))
{
if (descriptor.Relationship.RelationshipType.Name == "TransclusionRelationship")
{
IDescriptorProxy transMapDescriptor = descriptor.Relationship.Descriptors.Where(d => d.DescriptorType.Name == "TransclusionMap").First();
if (transMapDescriptor.NodeId != this.Navigator.FocalNodeId ||
descriptor.Relationship.Descriptors.Where(d => d.DescriptorType.Name == "From").Count() == 0)
{
continue;
}
}
IDescriptorProxy fromDescriptor = descriptor.Relationship.Descriptors.Where(d => d.DescriptorType.Name == "From").First();
if (this.ViewManager.CurrentView.NodeRenderers.ContainsKey(fromDescriptor.NodeId))
{
NodeRenderer childNodeRenderer = this.ViewManager.CurrentView.NodeRenderers[fromDescriptor.NodeId];
result.Add(childNodeRenderer);
}
}
return result;
}
/// <summary>
/// Used as the comparison for sorting the nodes based on their initial position.
/// </summary>
/// <param name="node1"></param>
/// <param name="node2"></param>
/// <returns></returns>
private int NodePositionComparison(NodeRenderer node1, NodeRenderer node2)
{
double node1YPosition = (double)node1.GetValue(Canvas.TopProperty);
double node2YPosition = (double)node2.GetValue(Canvas.TopProperty);
if (node1YPosition > node2YPosition)
{
return 1;
}
else if (node1YPosition < node2YPosition)
{
return -1;
}
else
{
return 0;
}
}
/// <summary>
/// Renders the node tree and process rendering attributes
/// </summary>
/// <param name="node"></param>
void renderNode(DTInspectorNode node)
{
if (serializedObject == null)
{
return;
}
bool guistate = GUI.enabled;
DTInspectorNode item;
for (int i = 0; i < node.Items.Count; i++)
{
item = node[i];
item.serializedObject = serializedObject;
if (item.Disabled)
{
GUI.enabled = false;
}
if (item is DTFieldNode)
{
DTFieldNode field = (DTFieldNode)item;
field.serializedProperty = serializedObject.FindProperty(field.SerializedPropertyPath);
if (field.serializedProperty == null)
{
return;
}
field.Calculate();
if (field.Visible)
{
foreach (var act in item.Actions)
{
if (act.Position == ActionAttribute.ActionPositionEnum.Above)
{
NodeRenderer.RenderAction(item, act, this, Target);
}
}
if (field.ArrayEx != null)
{
field.ArrayEx.serializedProperty = field.serializedProperty;
field.ArrayEx.DoLayoutList();
}
else
{
NodeRenderer.RenderField(field);
field.raiseOnRender();
}
foreach (var act in item.Actions)
{
if (act.Position == ActionAttribute.ActionPositionEnum.Below)
{
NodeRenderer.RenderAction(item, act, this, Target);
}
}
}
}
else if (item is DTGroupNode)
{
var group = (DTGroupNode)item;
group.Calculate();
if (group.Visible)
{
foreach (var act in item.Actions)
{
if (act.Position == ActionAttribute.ActionPositionEnum.Above)
{
NodeRenderer.RenderAction(item, act, this, Target);
}
}
if (group.Disabled)
{
GUI.enabled = false;
}
switch (item.RenderAs)
{
case DTInspectorNode.RenderAsEnum.Section:
NodeRenderer.RenderSectionHeader(group);
if (group.ContentVisible)
{
renderNode(group);
group.raiseOnRender();
}
NodeRenderer.RenderSectionFooter(group);
break;
case DTInspectorNode.RenderAsEnum.TabBar:
NodeRenderer.RenderTabBarHeader(group, (group.MaxItemsPerRow == -1) ? group.Items.Count:group.MaxItemsPerRow);
if (group.SelectedIndex > -1)
{
renderNode(group[group.SelectedIndex]);
group[group.SelectedIndex].raiseOnRender();
}
NodeRenderer.RenderTabBarFooter(group);
break;
default:
if (group.ContentVisible)
{
renderNode(group);
}
break;
}
foreach (var act in item.Actions)
{
if (act.Position == ActionAttribute.ActionPositionEnum.Below)
{
NodeRenderer.RenderAction(item, act, this, Target);
}
}
}
}
GUI.enabled = guistate;
if (item.NeedRepaint)
{
item.NeedRepaint = false;
NeedRepaint = true;
}
}
}
