/// <summary>
/// Reads incoming Json and parses it to the right implementation
/// </summary>
/// <param name="reader">Reader that has json</param>
/// <param name="objectType">objectType to which should be converted</param>
/// <param name="existingValue">A potentially existing value</param>
/// <param name="serializer">Serializer that is in use</param>
/// <returns>parsed object</returns>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var jsonObject = JObject.Load(reader);
//logger.Debug(objectType);
var graphItemType = default(object);
if (objectType == typeof(IVertex))
{
graphItemType = new Vertex();
}
else if (objectType == typeof(IEdge))
{
graphItemType = new Edge();
}
else if (objectType == typeof(IVertexValue))
{
graphItemType = new VertexValue();
}
else if (objectType == typeof(IVertexProperties))
{
graphItemType = new VertexProperties();
}
else if (objectType == typeof(IEdgeProperties))
{
graphItemType = new EdgeProperties();
}
else
{
throw (new Exceptions.NotSupportedDatabaseException("Not supported GraphDatabase. Titan or OrientDB are supported."));
}
serializer.Populate(jsonObject.CreateReader(), graphItemType);
return(graphItemType);
}
internal override void Populate(string property)
{
if (ProjectedProperties.Contains(property))
{
return;
}
EdgeProperties.Add(new GremlinProperty(GremlinKeyword.PropertyCardinality.single, property, null, null));
base.Populate(property);
}
internal override void Populate(string property)
{
if (ProjectedProperties.Contains(property))
{
return;
}
EdgeProperties.Add(property);
EdgeProperties.Add(null);
base.Populate(property);
}
void CopyEdgeProperties(EdgeProperties edgeFromInstance, EdgeProperties edgeToInstance)
{
edgeToInstance.fromNode = edgeFromInstance.fromNode;
edgeToInstance.toNode = edgeFromInstance.toNode;
edgeToInstance.flowType = edgeFromInstance.flowType;
edgeToInstance.flowRate = edgeFromInstance.flowRate;
edgeToInstance.dataClass = edgeFromInstance.dataClass;
edgeToInstance.isBidirectional = edgeFromInstance.isBidirectional;
edgeToInstance.fromLayerOrdinal = edgeFromInstance.fromLayerOrdinal;
edgeToInstance.toLayerOrdinal = edgeFromInstance.toLayerOrdinal;
}
public void AddStripToTriangleListHelper(Vertex start, Vertex end, float depth, EdgeProperties properties, List<VertexPositionColorNormalTexture> triangleList)
{
Vector3 edgeDir = end.position - start.position;
Vector3 edgeNormal = Vector3.Cross(end.position - start.position, start.normal);
edgeNormal.Normalize();
edgeDir.Normalize();
Color baseColor = Color.White;
if(properties.type == VL.EdgeType.Ice)
baseColor = Color.White;
if (properties.type == VL.EdgeType.Magnet)
baseColor = Color.Gray;
if (properties.type == VL.EdgeType.Bounce)
baseColor = Color.Magenta;
if (properties.type == VL.EdgeType.Electric)
{
if (properties.primaryValue == 0)
baseColor = new Color(40, 40, 40);
else
baseColor = Color.Yellow;
}
if (properties.type == VL.EdgeType.ConveyorBelt)
baseColor = Color.DarkGray;
if (properties.type != VL.EdgeType.Spikes)
{
float epsilon = .01f;
//side
triangleList.Add(GenerateTexturedVertex(start.position + epsilon * edgeNormal, blankTexCoords[1], baseColor, start.normal, depth + epsilon));
triangleList.Add(GenerateTexturedVertex(start.position - .5f * edgeNormal, blankTexCoords[1], baseColor, start.normal, depth + epsilon));
triangleList.Add(GenerateTexturedVertex(end.position + epsilon * edgeNormal, blankTexCoords[1], baseColor, start.normal, depth + epsilon));
triangleList.Add(GenerateTexturedVertex(end.position + epsilon * edgeNormal, blankTexCoords[1], baseColor, start.normal, depth + epsilon));
triangleList.Add(GenerateTexturedVertex(start.position - .5f * edgeNormal, blankTexCoords[1], baseColor, start.normal, depth + epsilon));
triangleList.Add(GenerateTexturedVertex(end.position - .5f * edgeNormal, blankTexCoords[1], baseColor, start.normal, depth + epsilon));
//top
triangleList.Add(GenerateTexturedVertex(start.position + epsilon * edgeNormal, blankTexCoords[1], baseColor, edgeNormal, depth + epsilon));
triangleList.Add(GenerateTexturedVertex(start.position + epsilon * edgeNormal, blankTexCoords[1], baseColor, edgeNormal, -depth));
triangleList.Add(GenerateTexturedVertex(end.position + epsilon * edgeNormal, blankTexCoords[1], baseColor, edgeNormal, depth + epsilon));
triangleList.Add(GenerateTexturedVertex(end.position + epsilon * edgeNormal, blankTexCoords[1], baseColor, edgeNormal, -depth));
triangleList.Add(GenerateTexturedVertex(start.position + epsilon * edgeNormal, blankTexCoords[1], baseColor, edgeNormal, -depth));
triangleList.Add(GenerateTexturedVertex(end.position + epsilon * edgeNormal, blankTexCoords[1], baseColor, edgeNormal, depth + epsilon));
}
if (properties.type == VL.EdgeType.Spikes)
{
int numSpikes = 2 * (int)(end.position - start.position).Length();
float spikeHeight = .75f;
float spikeWidth = (end.position - start.position).Length() / numSpikes;
Color spikeColor = new Color(180, 180, 180);
for (int i = 0; i < numSpikes; i++)
{
Vector3 spikeStart = start.position + i * spikeWidth * edgeDir;
Vector3 spikeEnd = start.position + (i + 1) * spikeWidth * edgeDir;
Vector3 spikePoint = .5f * (spikeStart + spikeEnd) + spikeHeight * edgeNormal;
Color shadedColor = Color.Blue;
shadedColor = FakeShader.Shade(spikeColor, start.normal);
triangleList.Add(GenerateTexturedVertex(spikeStart, blankTexCoords[1], shadedColor, start.normal, depth));
triangleList.Add(GenerateTexturedVertex(spikeEnd, blankTexCoords[1], shadedColor, start.normal, depth));
triangleList.Add(GenerateTexturedVertex(spikePoint, blankTexCoords[1], shadedColor, edgeNormal, depth / 2));
shadedColor = FakeShader.Shade(spikeColor, -start.normal);
triangleList.Add(GenerateTexturedVertex(spikeStart, blankTexCoords[1], shadedColor, -start.normal, 0));
triangleList.Add(GenerateTexturedVertex(spikeEnd, blankTexCoords[1], shadedColor, -start.normal, 0));
triangleList.Add(GenerateTexturedVertex(spikePoint, blankTexCoords[1], shadedColor, edgeNormal, depth / 2));
shadedColor = FakeShader.Shade(spikeColor, edgeDir);
triangleList.Add(GenerateTexturedVertex(spikeStart, blankTexCoords[1], shadedColor, edgeDir, depth));
triangleList.Add(GenerateTexturedVertex(spikeStart, blankTexCoords[1], shadedColor, edgeDir, 0));
triangleList.Add(GenerateTexturedVertex(spikePoint, blankTexCoords[1], shadedColor, edgeNormal, depth / 2));
shadedColor = FakeShader.Shade(spikeColor, -edgeDir);
triangleList.Add(GenerateTexturedVertex(spikeEnd, blankTexCoords[1], shadedColor, -edgeDir, depth));
triangleList.Add(GenerateTexturedVertex(spikeEnd, blankTexCoords[1], shadedColor, -edgeDir, 0));
triangleList.Add(GenerateTexturedVertex(spikePoint, blankTexCoords[1], shadedColor, edgeNormal, depth / 2));
}
}
if (properties.type == VL.EdgeType.ConveyorBelt)
{
int numSegments = (int)(end.position - start.position).Length();
float segmentWidth = (end.position - start.position).Length() / numSegments;
float arrowWidth = 0;
if (properties.primaryValue > 0)
arrowWidth = -.5f;
if (properties.primaryValue < 0)
arrowWidth = .5f;
for (int i = 1; i < numSegments; i++)
{
triangleList.Add(GenerateTexturedVertex(start.position + i * segmentWidth * edgeDir,blankTexCoords[1], Color.Yellow, start.normal, depth + .002f));
triangleList.Add(GenerateTexturedVertex(start.position + i * segmentWidth * edgeDir - .5f * edgeNormal,blankTexCoords[1], Color.Yellow, start.normal, depth + .002f));
triangleList.Add(GenerateTexturedVertex(start.position + arrowWidth * edgeDir + i * segmentWidth * edgeDir - .25f * edgeNormal,blankTexCoords[1], Color.Yellow, start.normal, depth + .002f));
}
}
}
public EdgeProperties GetProperties(Vector3 projection)
{
EdgeProperties properties = new EdgeProperties();
properties.type = VL.EdgeType.Normal;
foreach (Edge e in edges)
{
Vector3 edgeNormal = Vector3.Cross(e.start.normal, e.start.position - e.end.position);
edgeNormal.Normalize();
Vector3 projectionNormal = Vector3.Normalize(projection);
float result = Vector3.Dot(edgeNormal, projectionNormal);
if (result > .99f)
{
properties = e.properties;
}
}
return properties;
}
internal override void Property(GremlinToSqlContext currentContext, List <object> properties)
{
ProjectedProperties.Add(properties.First() as string);
EdgeProperties.AddRange(properties);
}
internal override void Property(GremlinToSqlContext currentContext, GremlinProperty property)
{
ProjectedProperties.Add(property.Key);
EdgeProperties.Add(property);
}
void SetupEdgeAnimation(Transform edgeInstance, Vector3 startPos, Vector3 endPos)
{
// add Animation
Transform objAnimationOut = edgeInstance.Find("AnimationOut");
Transform objAnimationIn = edgeInstance.Find("AnimationIn");
EdgeProperties edgeProperties = edgeInstance.gameObject.GetComponent <EdgeProperties>();
ParticleSystem objPartOut = objAnimationOut.GetComponentInChildren <ParticleSystem>();
ParticleSystem objPartIn = objAnimationIn.GetComponentInChildren <ParticleSystem>();
var pSmainOut = objPartOut.main;
var pSmainIn = objPartIn.main;
var pEmissionOut = objPartOut.emission;
var pEmissionIn = objPartIn.emission;
float dist = edgeInstance.localScale.z;
// set attributes
objAnimationOut.position = startPos;
objAnimationOut.LookAt(endPos);
pSmainOut.startLifetime = new ParticleSystem.MinMaxCurve(dist / objPartOut.main.startSpeed.constant);
pSmainIn.startLifetime = new ParticleSystem.MinMaxCurve(dist / objPartOut.main.startSpeed.constant);
// fix scale
objAnimationOut.localScale = new Vector3(hologramScale, hologramScale, hologramScale);
objAnimationIn.localScale = new Vector3(hologramScale, hologramScale, hologramScale);
/*
* Debug.Log("Edge: " + edgeInstance.transform.position);
* Debug.Log("Rotation: " + edgeInstance.transform.rotation);
* Debug.Log("Distance: " + dist);
* Debug.Log("startPos: " + startPos.ToString());
* Debug.Log("endPos " + endPos.ToString());
*/
// disable incoming if not both directional
if (!edgeProperties.isBidirectional.Equals(true))
{
pEmissionIn.enabled = false;
}
else
{
// set up incoming link in opposite direction
objAnimationIn.position = endPos;
objAnimationIn.LookAt(startPos);
}
// delay for EOD
if (edgeProperties.flowRate.Equals("EOD"))
{
pEmissionOut.rateOverTime = pEmissionOut.rateOverTime.constant / EODdelay;
pEmissionIn.rateOverTime = pEmissionOut.rateOverTime;
}
// change color for integration types
/*
* switch (edgeProperties.flowType)
* {
* case "API":
* pSmainOut.startColor = new Color(72, 54, 128); // blue
* break;
* case "Batch":
* pSmainOut.startColor = new Color(221, 133, 10); // orange
* break;
* case "MSG":
* pSmainOut.startColor = new Color(131, 42, 42); // red
* break;
* }
*/
}
//Color HexToColor(string hex)
//{
// byte R = (byte)((HexVal >> 16) & 0xFF);
// byte G = (byte)((HexVal >> 8) & 0xFF);
// byte B = (byte)((HexVal) & 0xFF);
// return new Color32(R, G, B, 255);
//}
//void AddChildTag(Transform trn, string tag)
//{
// //create empty child object to hold tag
// GameObject child = new GameObject("Tag");
// //tag child
// child.tag = tag;
// //add tag to game object
// child.transform.parent = trn.transform;
//}
void DrawEdges(Transform yearContainer)
{
//Debug.Log("start draw edges");
Transform edgeContainer = Instantiate(prefabEdgeContainer, new Vector3(0, 0, 0), Quaternion.identity, yearContainer);
edgeContainer.name = "EdgeContainer";
edgeContainer.localPosition = new Vector3(0, 0, 0);
foreach (XElement edge in xmlEdges)
{
//Debug.Log(edge.Attribute("source").Value);
GameObject startNode = GameObject.Find(edge.Attribute("source").Value);
GameObject endNode = GameObject.Find(edge.Attribute("target").Value);
//GameObject startNode = yearContainer.Find(edge.Attribute("source").Value).gameObject;
//GameObject endNode = yearContainer.Find(edge.Attribute("target").Value).gameObject;
Vector3 centerPosition = (startNode.transform.position + endNode.transform.position) / 2f;
float dist = Vector3.Distance(startNode.transform.position, endNode.transform.position);
//Transform edgeInstance = Instantiate(prefabEdge, startNode.transform.position, Quaternion.identity, yearContainer);
Transform edgeInstance = Instantiate(prefabEdge, centerPosition, Quaternion.identity, edgeContainer);
edgeInstance.LookAt(endNode.transform);
edgeInstance.transform.localScale = new Vector3(edgexscale, edgeyscale, dist);
EdgeProperties edgeProperties = edgeInstance.gameObject.GetComponent <EdgeProperties>();
edgeProperties.fromNode = edge.Attribute("source").Value;
edgeProperties.toNode = edge.Attribute("target").Value;
edgeProperties.flowType = edge.Descendants().Where(a => a.Attribute("key").Value == "e_Type").Select(a => a.Value).FirstOrDefault();;
edgeProperties.flowRate = edge.Descendants().Where(a => a.Attribute("key").Value == "e_Frequency").Select(a => a.Value).FirstOrDefault();;;
edgeProperties.dataClass = edge.Descendants().Where(a => a.Attribute("key").Value == "e_Data").Select(a => a.Value).FirstOrDefault();;;
edgeProperties.isBidirectional = (int.Parse(edge.Descendants().Where(a => a.Attribute("key").Value == "e_Direction").Select(a => a.Value).FirstOrDefault()) == 2);
edgeProperties.fromLayerOrdinal = int.Parse(startNode.GetComponent <NodeProperties>().LayerOrdinal);
edgeProperties.toLayerOrdinal = int.Parse(endNode.GetComponent <NodeProperties>().LayerOrdinal);
edgeProperties.IsConnected = false;
edgeInstance.name = edgeProperties.fromNode + '>' + edgeProperties.toNode;
// bent edges
if (edgeProperties.fromLayerOrdinal.Equals(2) && edgeProperties.toLayerOrdinal.Equals(2))
{
float ydrop = yscale * yBentMean - Random.Range(yBentDrop, yBentDrop + 1f);
// drop existing
edgeInstance.transform.position = new Vector3(centerPosition.x, centerPosition.y - ydrop, centerPosition.z);
SetupEdgeAnimation(edgeInstance, new Vector3(startNode.transform.position.x, startNode.transform.position.y - ydrop, startNode.transform.position.z), new Vector3(endNode.transform.position.x, endNode.transform.position.y - ydrop, endNode.transform.position.z));
// add drop
Vector3 centerDropPosition = new Vector3(startNode.transform.position.x, startNode.transform.position.y - ydrop / 2, startNode.transform.position.z);
Transform edgeDropInstance = Instantiate(prefabEdge, centerDropPosition, Quaternion.identity, edgeContainer);
edgeDropInstance.transform.localScale = new Vector3(edgexscale, edgeyscale, ydrop);
edgeDropInstance.LookAt(new Vector3(startNode.transform.position.x, startNode.transform.position.y - ydrop, startNode.transform.position.z));
edgeDropInstance.name = edgeProperties.fromNode + '>' + edgeProperties.toNode + "- DROP";
EdgeProperties edgeDropProperties = edgeDropInstance.gameObject.GetComponent <EdgeProperties>();
CopyEdgeProperties(edgeProperties, edgeDropProperties);
SetupEdgeAnimation(edgeDropInstance, new Vector3(startNode.transform.position.x, startNode.transform.position.y, startNode.transform.position.z), new Vector3(startNode.transform.position.x, startNode.transform.position.y - ydrop, startNode.transform.position.z));
// add go up
Vector3 centerUpPosition = new Vector3(endNode.transform.position.x, endNode.transform.position.y - ydrop / 2, endNode.transform.position.z);
Transform edgeUpInstance = Instantiate(prefabEdge, centerUpPosition, Quaternion.identity, edgeContainer);
edgeUpInstance.transform.localScale = new Vector3(edgexscale, edgeyscale, ydrop);
edgeUpInstance.LookAt(new Vector3(endNode.transform.position.x, endNode.transform.position.y, endNode.transform.position.z));
edgeUpInstance.name = edgeProperties.fromNode + '>' + edgeProperties.toNode + "- UP";
EdgeProperties edgeUpProperties = edgeUpInstance.gameObject.GetComponent <EdgeProperties>();
CopyEdgeProperties(edgeProperties, edgeUpProperties);
SetupEdgeAnimation(edgeUpInstance, new Vector3(endNode.transform.position.x, endNode.transform.position.y - ydrop, endNode.transform.position.z), new Vector3(endNode.transform.position.x, endNode.transform.position.y, endNode.transform.position.z));
}
else
{
SetupEdgeAnimation(edgeInstance, startNode.transform.position, endNode.transform.position);
}
//tag edges with node layers
//AddChildTag(edgeInstance, "Layer" + startNode.GetComponent<NodeProperties>().LayerOrdinal);
//AddChildTag(edgeInstance, "Layer" + endNode.GetComponent<NodeProperties>().LayerOrdinal);
//var edgeData = edgeInstance.transform.GetComponent<EdgeData>();
//LineRenderer lineRenderer = gameObject.AddComponent<LineRenderer>();
//lineRenderer.material = new Material(Shader.Find("Particles/Additive"));
//lineRenderer.widthMultiplier = 0.1f;
////lineRenderer.positionCount = lengthOfLineRenderer;
//lineRenderer.SetPosition(0, new Vector3(startNode.transform.position.x, startNode.transform.position.y, startNode.transform.position.z));
//lineRenderer.SetPosition(1, new Vector3(endNode.transform.position.x, endNode.transform.position.y, endNode.transform.position.z));
////A simple 2 color gradient with a fixed alpha of 1.0f.
//float alpha = 1.0f;
//Gradient gradient = new Gradient();
//gradient.SetKeys(
// new GradientColorKey[] { new GradientColorKey(c1, 0.0f), new GradientColorKey(c2, 1.0f) },
// new GradientAlphaKey[] { new GradientAlphaKey(alpha, 0.0f), new GradientAlphaKey(alpha, 1.0f) }
// );
//lineRenderer.colorGradient = gradient;
}
}
