GraphVizUtilities.cs

using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Waher.Content.Semantic;
using Waher.Content.Semantic.Model;
using Waher.Content.Semantic.Model.Literals;
using Waher.Script;
 
namespace Waher.Content.Markdown.GraphViz
{
    public static class GraphVizUtilities
    {
        #region Converting a GraphViz diagram to an image
 
        public static Task<byte[]> DotToImage(string GraphText, ResultType ResultType)
        {
            return GraphVizToImage("dot", GraphText, ResultType);
        }
 
        public static Task<byte[]> NeatoToImage(string GraphText, ResultType ResultType)
        {
            return GraphVizToImage("neato", GraphText, ResultType);
        }
 
        public static Task<byte[]> FdpToImage(string GraphText, ResultType ResultType)
        {
            return GraphVizToImage("fdp", GraphText, ResultType);
        }
 
        public static Task<byte[]> SfdpToImage(string GraphText, ResultType ResultType)
        {
            return GraphVizToImage("sfdp", GraphText, ResultType);
        }
 
        public static Task<byte[]> TwoPiToImage(string GraphText, ResultType ResultType)
        {
            return GraphVizToImage("twopi", GraphText, ResultType);
        }
 
        public static Task<byte[]> CircoToImage(string GraphText, ResultType ResultType)
        {
            return GraphVizToImage("circo", GraphText, ResultType);
        }
 
        public static Task<byte[]> GraphVizToImage(string Language, string GraphText,
            ResultType ResultType)
        {
            return GraphVizToImage(Language, GraphText, ResultType, new Variables());
        }
 
        public static async Task<byte[]> GraphVizToImage(string Language, string GraphText,
            ResultType ResultType, Variables Variables)
        {
            GraphInfo Graph = await GraphViz.GetFileName(Language, GraphText, ResultType, true, Variables);
            return await Runtime.IO.Files.ReadAllBytesAsync(Graph.FileName);
        }
 
        #endregion
 
        #region Converting semantic graphs to a GraphViz diagram
 
        public static string GenerateGraph(ISemanticModel Graph, string Title)
        {
            return GenerateGraph(null, Graph, Title);
        }
 
        public static string GenerateGraph(SparqlResultSet ResultSet, ISemanticModel Graph, string Title)
        {
            if (ResultSet is null)
                ResultSet = new SparqlResultSet(false); // Object only used for shortening URIs and Blank Nodes.
 
            StringBuilder sb = new StringBuilder();
            Dictionary<string, string> NodeNames = new Dictionary<string, string>();
 
            sb.AppendLine("digraph G {");
            sb.AppendLine("\trankdir=LR");
            sb.AppendLine("\tbgcolor=\"transparent\"");
            sb.AppendLine("\tnode [style=filled,fillcolor=white]");
 
            if (!string.IsNullOrEmpty(Title))
            {
                sb.Append("\tlabel=\"");
                sb.Append(JSON.Encode(Title));
                sb.AppendLine("\"");
                sb.AppendLine("\tlabelloc=\"t\"");
                sb.AppendLine("\tfontsize=20");
            }
 
            int LiteralIndex = 0;
 
            foreach (ISemanticTriple Triple in Graph)
            {
                AddShortName(ResultSet, Triple.Subject, NodeNames, sb, ref LiteralIndex);
                AddShortName(ResultSet, Triple.Object, NodeNames, sb, ref LiteralIndex);
            }
 
            LiteralIndex = 0;
 
            foreach (ISemanticTriple Triple in Graph)
            {
                sb.Append("\t");
                sb.Append(GetNodeName(ResultSet, Triple.Subject, NodeNames, false, ref LiteralIndex));
                sb.Append(" -> ");
                sb.Append(GetNodeName(ResultSet, Triple.Object, NodeNames, false, ref LiteralIndex));
                sb.Append(" [label=\"");
                sb.Append(JSON.Encode(GetNodeName(ResultSet, Triple.Predicate, null, true, ref LiteralIndex)));
                sb.AppendLine("\"]");
            }
 
            sb.AppendLine("}");
 
            return sb.ToString();
        }
 
        private static string GetNodeName(SparqlResultSet Result, ISemanticElement Element,
            Dictionary<string, string> NodeNames, bool IgnoreLiteral, ref int LiteralIndex)
        {
            string Name;
 
            if (Element is UriNode UriNode)
                Name = Result.GetShortUri(UriNode);
            else if (Element is BlankNode BlankNode)
                Name = Result.GetShortBlankNodeLabel(BlankNode);
            else if (Element is SemanticLiteral)
            {
                if (IgnoreLiteral)
                    return "\"" + Element.ToString().Replace("\"", "\\\"") + "\"";
                else
                    return "L" + (++LiteralIndex).ToString();
            }
            else
                Name = Element.ToString();
 
            if (NodeNames is null)
                return Name;
            else
                return NodeNames[Name];
        }
 
        private static void AddShortName(SparqlResultSet Result, ISemanticElement Element,
            Dictionary<string, string> NodeNames, StringBuilder sb, ref int LiteralIndex)
        {
            string Name;
            string NodeName = null;
            string AdditionalStyle = null;
 
            if (Element is UriNode UriNode)
            {
                Name = Result.GetShortUri(UriNode);
                AdditionalStyle = ",fillcolor=azure";
            }
            else if (Element is BlankNode BlankNode)
            {
                Name = Result.GetShortBlankNodeLabel(BlankNode);
                AdditionalStyle = ",fillcolor=lightgray";
            }
            else if (Element is SemanticLiteral SemanticLiteral)
            {
                string Type = SemanticLiteral.StringType;
                string ShortType = Result.GetShortUri(SemanticLiteral.StringType);
 
                NodeName = "L" + (++LiteralIndex).ToString();
                AdditionalStyle = ",fillcolor=honeydew,shape=box,style=\"rounded,filled\",margin=\"0.2,0\",height=0.35";
 
                if (ShortType == Type)
                    Name = Element.ToString();
                else if (SemanticLiteral is CustomLiteral CustomLiteral)
                {
                    Name = CustomLiteral.ToString(CustomLiteral.StringValue,
                        CustomLiteral.Language, ShortType);
                }
                else
                {
                    Name = CustomLiteral.ToString(SemanticLiteral.StringValue,
                        null, ShortType);
                }
            }
            else
                Name = Element.ToString();
 
            if (string.IsNullOrEmpty(NodeName))
            {
                NodeName = "N" + (NodeNames.Count + 1).ToString();
                if (NodeNames.ContainsKey(Name))
                    return;
                
                NodeNames[Name] = NodeName;
            }
 
            sb.Append("\t");
            sb.Append(NodeName);
            sb.Append(" [label=\"");
            sb.Append(JSON.Encode(Name));
            sb.Append('"');
 
            if (!string.IsNullOrEmpty(AdditionalStyle))
                sb.Append(AdditionalStyle);
 
            sb.AppendLine("]");
        }
 
        #endregion
    }
}