private Image GetPieGraph()
{
var ru = new RandomUtil();
var pg = new PieGraph(Size);
pg.Color = Color.White;
pg.ColorGradient = Color.Orange;
var legend = new Legend(Width, 70);
legend.Text = string.Empty;
pg.Text = _displayString + " Total: " + _totalComponents.ToString();
var keys = _componentInfoTable.Keys;
var ie = keys.GetEnumerator();
while (ie.MoveNext())
{
Type key = (Type)ie.Current;
ComponentInfo ci = (ComponentInfo)_componentInfoTable[key];
var ps = new PieSlice(ci.Count, ci.Color);
pg.Slices.Add(ps);
var le = new LegendEntry(ci.Color, ci.Type.Name.ToString().Trim());
legend.LegendEntryCollection.Add(le);
}
return(GraphRenderer.DrawGraphAndLegend(pg, legend, Size));
}
public override void RenderContent(Graphics graphics)
{
var size = ContentBounds.Size;
using (var path = GraphRenderer.CreateRoundedRectangle(size, ContentBounds.Location))
{
var rect = ContentBounds;
if (this.Checked)
{
using (var brush = new SolidBrush(Color.FromArgb(128 + 32, Color.White)))
{
graphics.FillPath(brush, path);
}
}
else
{
using (var brush = new SolidBrush(Color.FromArgb(64, Color.Black)))
{
graphics.FillPath(brush, path);
}
}
graphics.DrawString(this.Text, SystemFonts.MenuFont, Node.TextColor, rect, GraphConstants.CenterTextStringFormat);
if ((state & RenderState.Hover) != 0)
{
graphics.DrawPath(Pens.White, path);
}
else
{
graphics.DrawPath(Pens.Black, path);
}
}
}
static void DrawGraphLayout()
{
var graph = new Graph("graph");
graph.AddEdge("A", "B");
graph.AddEdge("B", "C");
graph.AddEdge("A", "C").Attr.Color = Color.Green;
graph.FindNode("A").Attr.FillColor = Color.Magenta;
graph.FindNode("B").Attr.FillColor = Color.MistyRose;
var c = graph.FindNode("C");
c.Attr.FillColor = Color.PaleGreen;
c.Attr.Shape = Shape.Diamond;
graph.Attr.LayerDirection = LayerDirection.BT;
var renderer = new GraphRenderer(graph);
renderer.CalculateLayout();
int width = 1400;
int height = 200;
var bitmap = new System.Drawing.Bitmap(width, height, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
renderer.Render(bitmap);
bitmap.Save("graph.bmp");
}
/// <summary>
/// Render the graph to an image
/// </summary>
/// <param name="graph">The graph to be rendered</param>
/// <param name="width">Width of the image. Will be calculated relatively if not provided</param>
/// <param name="height">Height of the image. Will be calculated relatively if not provided</param>
/// <returns>The rendered Bitmap</returns>
public static Bitmap RenderImage(this Graph graph, int width = -1, int height = -1)
{
var renderer = new GraphRenderer(graph);
renderer.CalculateLayout();
if (width == -1 && height == -1)
{
width = (int)(Math.Sqrt(graph.NodeCount)) * 150;
}
else if (width != -1 && height != -1)
{
if (width / height > graph.Width / graph.Height)
{
height = -1;
}
else
{
width = -1;
}
}
if (width == -1)
{
width = (int)Math.Round(graph.Width / graph.Height * height);
}
else
{
height = (int)Math.Round(graph.Height / graph.Width * width);
}
var image = new Bitmap(width, height);
renderer.Render(image);
return(image);
}
int ProcessDotFile(string inputFile)
{
Graph graph;
int i = CreateGraphFromDotFile(inputFile, out graph);
if (i != 0)
{
return(i);
}
graph.LayoutAlgorithmSettings = PickLayoutAlgorithmSettings(graph.EdgeCount, graph.NodeCount);
if (argsParser.OptionIsUsed(NoArrowheads))
{
RemoveArrowheadsFromGraph(graph);
}
EnlargeLabelMargins(graph);
SetConsolasFontAndSize(graph, 13);
// rendering
var renderer = new GraphRenderer(graph);
renderer.CalculateLayout();
SetBoxRadiuses(graph);
var outputFile = Path.ChangeExtension(inputFile, ".svg");
string outputDir = argsParser.GetValueOfOptionWithAfterString(OutputDirOption);
if (outputDir != null)
{
var name = Path.GetFileName(outputFile);
if (name != null)
{
outputFile = Path.Combine(outputDir, name);
}
}
SetConsolasFontAndSize(graph, 11);
if (argsParser.OptionIsUsed(NoLabelsOption))
{
RemoveLabelsFromGraph(graph);
}
var svgWriter = new SvgGraphWriter(File.Create(outputFile), graph)
{
NodeSanitizer = AntiXss.HtmlAttributeEncode, AttrSanitizer = AntiXss.HtmlAttributeEncode,
Precision = precision, AllowedToWriteUri = !argsParser.OptionIsUsed(NoUrls)
};
svgWriter.Write();
DumpFileToConsole(outputFile);
if (msaglOutput)
{
outputFile = SetMsaglOutputFileName(inputFile);
var geomGraph = graph.GeometryGraph;
WriteGeomGraph(outputFile, geomGraph);
}
return(0);
}
public MainWindow()
{
if (Instance == null)
{
Instance = this;
}
InitializeComponent();
Graph = GraphGenerator.generatorRegular(2);
GraphRenderer = new GraphRenderer(Graph, GraphControl, VM);
GraphListControl.DataContext = new GraphListViewModel();
GraphControl.OnTwoNodeClickEvent += ConnectTwoNodes;
GraphControl.OnLineClick += createWeight;
Graph.OnChange += onGraphChange;
onGraphChange();
this.DataContext = VM;
}
private void Initialize()
{
graph = new Graph();
fdg = new ForceDirected3D(graph, Stiffness, Repulsion, Damping);
fdg.Threadshold = Threadshold;
graphRenderer = new GraphRenderer(this, fdg);
}
/// <summary>
/// Starts a graph with the given values.
/// </summary>
/// <param name="values">A list of floats which you want to display. Can be empty.</param>
/// <param name="displayedSeconds">How many seconds you want to display (time frame).</param>
public void Initialize(List <float> values, float displayedSeconds)
{
// return when the function is called with bad values
if (values == null)
{
values = new List <float>();
}
if (displayedSeconds < 2 * Time.deltaTime)
{
Debug.Log("Cannot start a graph with less than 2 points!");
return;
}
m_GraphRenderer = gameObject.AddComponent <GraphRenderer>();
// fill the list if necessary
if (values.Count < m_DisplayedPointsCount)
{
m_Values = values;
m_Values.AddRange(Enumerable.Repeat(m_DefaultValue, m_DisplayedPointsCount).ToList());
}
// init values
m_Values = values;
// init graph renderer
m_GraphRenderer.Initialize(m_Values, m_DisplayedPointsCount);
DisplayForNumberOfSeconds(displayedSeconds);
}
public static Bitmap PlottToBitMap(IEnumerable <IGraphNode> plottables, int imgsize = 500)
{
Graph graph = new Graph("");
foreach (var node in plottables)
{
if (node.NodeColor != Microsoft.Glee.Drawing.Color.Transparent)
{
Node n = graph.AddNode(node.NodeName);
n.Attr.Fillcolor = node.NodeColor;
}
foreach (var edge in node.NodeConnectedTo)
{
Edge newedge = graph.AddEdge(node.NodeName, edge.Text, edge.TargetNode);
newedge.Attr.Fontsize = 10;
if (edge.CustomEdgeAttr != null)
{
newedge.EdgeAttr = edge.CustomEdgeAttr;
}
//if (edge.Color != Microsoft.Glee.Drawing.Color.Transparent)
// newedge.Attr.Color = edge.Color;
}
}
GraphRenderer renderer = new GraphRenderer(graph);
renderer.CalculateLayout();
Bitmap bitmap = new Bitmap(imgsize, (int)(graph.Height *
(imgsize / graph.Width)), PixelFormat.Format32bppPArgb);
renderer.Render(bitmap);
return(bitmap);
}
public void OnGet(string font, ushort index = 0)
{
if (!_typefaces.ContainsKey(font))
{
font = "Roboto-Regular.ttf";
}
if (index < 0 || _typefaces[font].GlyphCount <= index)
{
index = 0;
}
var tf = _typefaces[font];
var emsize = 200;
var renderer = new GraphRenderer();
var typefaceGeometry = tf.GetGlyphOutline(index, emsize);
Graph = renderer.CreateGraph(
typefaceGeometry,
tf.Baseline,
tf.AdvanceWidths[index],
tf.AdvanceHeights[index],
tf.LeftSideBearings[index],
tf.RightSideBearings[index],
tf.TopSideBearings[index],
tf.BottomSideBearings[index],
emsize);
}
internal override void Render(Graphics graphics, SizeF minimumSize, PointF location)
{
var size = Measure(graphics);
size.Width = Math.Max(minimumSize.Width, size.Width);
size.Height = Math.Max(minimumSize.Height, size.Height);
var path = GraphRenderer.CreateRoundedRectangle(size, location);
graphics.FillPath(background, path);
location.Y += 1;
location.X += 1;
if ((state & RenderState.Hover) == RenderState.Hover)
{
graphics.DrawPath(Pens.White, path);
graphics.DrawString(this.FormattedText, SystemFonts.MenuFont, Brushes.Black, new RectangleF(location, size), GraphConstants.LeftTextStringFormat);
}
else
{
graphics.DrawPath(Pens.Black, path);
graphics.DrawString(this.FormattedText, SystemFonts.MenuFont, Brushes.Black, new RectangleF(location, size), GraphConstants.LeftTextStringFormat);
}
}
private Image GetBarGraph()
{
RandomUtil ru = new RandomUtil();
BarGraph bg = new BarGraph(this.Size);
bg.Color = Color.White;
bg.ColorGradient = Color.Orange;
Legend legend = new Legend(this.Width, 70);
legend.Text = String.Empty;
bg.Text = _displayString + " Total: " + _totalComponents.ToString();
ICollection keys = _componentInfoTable.Keys;
IEnumerator ie = keys.GetEnumerator();
while (ie.MoveNext())
{
Type key = (Type)ie.Current;
ComponentInfo ci = (ComponentInfo)_componentInfoTable[key];
BarSlice bs = new BarSlice(ci.Count, ci.Color);
bg.BarSliceCollection.Add(bs);
LegendEntry le = new LegendEntry(ci.Color, ci.Type.Name.ToString().Trim());
legend.LegendEntryCollection.Add(le);
}
return(GraphRenderer.DrawGraphAndLegend(bg, legend, this.Size));
}
internal override void Render(Graphics graphics, SizeF minimumSize, PointF location)
{
var text = string.Empty;
if (Items != null &&
SelectedIndex >= 0 && SelectedIndex < Items.Length)
{
text = Items[SelectedIndex];
}
var size = Measure(graphics);
size.Width = Math.Max(minimumSize.Width, size.Width);
size.Height = Math.Max(minimumSize.Height, size.Height);
var path = GraphRenderer.CreateRoundedRectangle(size, location);
location.Y += 1;
location.X += 1;
if ((state & RenderState.Hover) == RenderState.Hover)
{
graphics.DrawPath(Pens.White, path);
graphics.DrawString(text, SystemFonts.MenuFont, Brushes.Black, new RectangleF(location, size), GraphConstants.LeftTextStringFormat);
}
else
{
graphics.DrawPath(Pens.Black, path);
graphics.DrawString(text, SystemFonts.MenuFont, Brushes.Black, new RectangleF(location, size), GraphConstants.LeftTextStringFormat);
}
}
public override void RenderContent(Graphics graphics)
{
var text = string.Empty;
if (Items != null &&
SelectedIndex >= 0 && SelectedIndex < Items.Length)
{
text = Items[SelectedIndex];
}
var path = GraphRenderer.CreateRoundedRectangle(ContentBounds.Size, ContentBounds.Location);
var location = ContentBounds.Location;
location.Y += 1;
location.X += 1;
if ((state & RenderState.Hover) == RenderState.Hover)
{
graphics.DrawPath(Pens.White, path);
graphics.DrawString(text, SystemFonts.MenuFont, Node.TextColor, new RectangleF(location, ContentBounds.Size), GraphConstants.LeftTextStringFormat);
}
else
{
graphics.DrawPath(Pens.Black, path);
graphics.DrawString(text, SystemFonts.MenuFont, Node.TextColor, new RectangleF(location, ContentBounds.Size), GraphConstants.LeftTextStringFormat);
}
}
void Awake()
{
Singleton = this;
graph = new Graph(InitializeGraphBackend());
graphScene = new GraphScene(graph, graphScenePrefabs);
ResultPanel.SetActive(false);
ResultText.gameObject.SetActive(false);
}
private void RedrawGraph(Graph graph, Func <Node, Size, UserControl> controlBuilder, Size nodeSize)
{
var renderer = new GraphRenderer(graphCanvas, controlBuilder, nodeSize);
var layout = new GraphLayoutEngine();
layout.Layout(graph);
renderer.Render(graph);
}
internal override void Render(Graphics graphics, SizeF minimumSize, PointF location)
{
var size = Measure(graphics);
size.Width = Math.Max(minimumSize.Width, size.Width);
size.Height = Math.Max(minimumSize.Height, size.Height);
var sliderOffset = Spacing + this.textSize.Width;
var sliderWidth = size.Width - (Spacing + this.textSize.Width);
var textRect = new RectangleF(location, size);
var sliderBox = new RectangleF(location, size);
var sliderRect = new RectangleF(location, size);
sliderRect.X = sliderRect.Right - sliderWidth;
sliderRect.Y += ((sliderRect.Bottom - sliderRect.Top) - SliderHeight) / 2.0f;
sliderRect.Width = sliderWidth;
sliderRect.Height = SliderHeight;
textRect.Width -= sliderWidth + Spacing;
var valueSize = (this.MaxValue - this.MinValue);
this.sliderRect = sliderRect;
this.sliderRect.Width -= SliderBoxSize;
this.sliderRect.X += SliderBoxSize / 2.0f;
sliderBox.Width = SliderBoxSize;
sliderBox.X = sliderRect.X + (this.Value * this.sliderRect.Width) / valueSize;
graphics.DrawString(this.Text, SystemFonts.MenuFont, Brushes.Black, textRect, GraphConstants.LeftTextStringFormat);
using (var path = GraphRenderer.CreateRoundedRectangle(sliderRect.Size, sliderRect.Location))
{
if ((state & (RenderState.Hover | RenderState.Dragging)) != 0)
{
graphics.DrawPath(Pens.White, path);
}
else
{
graphics.DrawPath(Pens.Black, path);
}
}
graphics.FillRectangle(Brushes.LightGray, sliderBox.X, sliderBox.Y, sliderBox.Width, sliderBox.Height);
if ((state & (RenderState.Hover | RenderState.Dragging)) != 0)
{
graphics.DrawRectangle(Pens.White, sliderBox.X, sliderBox.Y, sliderBox.Width, sliderBox.Height);
}
else
{
graphics.DrawRectangle(Pens.Black, sliderBox.X, sliderBox.Y, sliderBox.Width, sliderBox.Height);
}
}
private void WindowReset()
{
AllReset();
myGraphRenderer = new GraphRenderer();
ChangeStyle("默认样式");
StatusUpdateTimer_Init();
myGdb = new Graph(myDataBasePath);
FillNodeList();
myIsModified = false;
myIsDbAvailable = true;
}
public void SaveGraphToFile(FeatherVaneGraph data, int width, int height, string filename)
{
Graph gleeGraph = CreateGraph(data);
var renderer = new GraphRenderer(gleeGraph);
renderer.CalculateLayout();
var bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb);
renderer.Render(bitmap);
bitmap.Save(filename, ImageFormat.Png);
}
private void DrawGeneralStats()
{
spriteBatch.Begin();
Primitives2D.FillRectangle(spriteBatch, new Rectangle(0, 0, 300, 600), AdditionalColors.TRANSPARENTBLACK);
spriteBatch.DrawString(Fonts.FontArial, "#: " + Creatures.Count, new Vector2(20, 20), Color.Red);
spriteBatch.DrawString(Fonts.FontArial, "D: " + numberOfDeaths, new Vector2(20, 40), Color.Red);
spriteBatch.DrawString(Fonts.FontArial, "max(G): " + Creature.maximumGeneration, new Vector2(20, 60), Color.Red);
spriteBatch.DrawString(Fonts.FontArial, "Y: " + year, new Vector2(20, 80), Color.Red);
spriteBatch.DrawString(Fonts.FontArial, "LS: " + Creature.oldestCreatureEver.Age + " g: " + Creature.oldestCreatureEver.Generation, new Vector2(20, 100), Color.Red);
spriteBatch.DrawString(Fonts.FontArial, "LSA: " + OldestCreatureAlive.Age + " g: " + OldestCreatureAlive.Generation, new Vector2(20, 120), Color.Red);
if (AverageAgeOfLastCreaturesAccurate)
{
float averageDeathAge = CalculateAverageAgeOfLastDeadCreatures();
AverageDeathAgeRecord.Add(averageDeathAge);
spriteBatch.DrawString(Fonts.FontArial, "AvgDA: " + averageDeathAge, new Vector2(20, 140), Color.Red);
}
if (EvoGame.Instance.inputManager.EnableFastForward)
{
spriteBatch.DrawString(Fonts.FontArial, "Graph rendering disabled", new Vector2(20, 180), Color.Red);
spriteBatch.DrawString(Fonts.FontArial, "during fast forward!", new Vector2(20, 200), Color.Red);
}
else
{
spriteBatch.DrawString(Fonts.FontArial, "Creatures Alive Graph ", new Vector2(20, 180), Color.Red);
GraphRenderer.RenderGraph(spriteBatch, new Rectangle(20, 200, 260, 100), Color.Blue, AliveCreaturesRecord, Fonts.FontArial, true);
spriteBatch.DrawString(Fonts.FontArial, "Average Age on Death Graph ", new Vector2(20, 320), Color.Red);
if (AverageAgeOfLastCreaturesAccurate)
{
GraphRenderer.RenderGraph(spriteBatch, new Rectangle(20, 340, 260, 100), Color.Red, AverageDeathAgeRecord, Fonts.FontArial, true);
}
spriteBatch.DrawString(Fonts.FontArial, "Food Available Graph ", new Vector2(20, 460), Color.Red);
GraphRenderer.RenderGraph(spriteBatch, new Rectangle(20, 480, 260, 100), Color.Green, EvoGame.Instance.tileMap.FoodRecord, Fonts.FontArial, true);
}
if (SelectedCreature != null)
{
Primitives2D.FillRectangle(spriteBatch, new Rectangle(800, 0, 500, 450), AdditionalColors.TRANSPARENTBLACK);
spriteBatch.DrawString(Fonts.FontArial, "Selected Creature: ", new Vector2(820, 50), Color.Red);
spriteBatch.DrawString(Fonts.FontArial, "A: " + SelectedCreature.Age, new Vector2(820, 70), Color.Red);
spriteBatch.DrawString(Fonts.FontArial, "E: " + SelectedCreature.Energy, new Vector2(820, 90), Color.Red);
spriteBatch.DrawString(Fonts.FontArial, "C: " + SelectedCreature.Children.Count, new Vector2(820, 110), Color.Red);
spriteBatch.DrawString(Fonts.FontArial, "G: " + SelectedCreature.Generation, new Vector2(820, 130), Color.Red);
spriteBatch.DrawString(Fonts.FontArial, "S: " + (SelectedCreature.Energy > 100 ? "Alive" : "Dead"), new Vector2(820, 150), Color.Red);
SelectedCreature.DrawCreature(spriteBatch, SelectedCreature.Pos * -1 + new Vector2(1050, 70));
SelectedCreature.Brain.Draw(spriteBatch, new Rectangle(950, 160, 200, 250));
}
spriteBatch.End();
}
private void UpdateGraph()
{
var includeDescriptions = buttonDescriptions.Checked;
var labelFont = string.Empty;
var renderer = new GraphRenderer(includeDescriptions, labelFont, 12);
showGraph.Image = renderer.Render(mProjects);
bool haveGraph = showGraph.Image != null;
buttonSave.Enabled = haveGraph;
paneWelcome.Visible = !haveGraph;
showGraph.Visible = haveGraph;
}
private void DrawGraph(Graphics g, int w, int h, float scale, Graph graph, GraphRenderer renderer)
{
var num1 = (float)(0.5 * w - scale * (graph.Left + 0.5 * graph.Width));
var num2 = (float)(0.5 * h + scale * (graph.Bottom + 0.5 * graph.Height));
using (var brush = new SolidBrush(Draw.MsaglColorToDrawingColor(graph.Attr.BackgroundColor)))
g.FillRectangle(brush, 0, 0, w, h);
using (var matrix = new Matrix(scale, 0f, 0f, -scale, num1, num2))
{
g.Transform = matrix;
Draw.DrawPrecalculatedLayoutObject(g, renderer);
}
}
private static void ToBitmap(Graph graph)
{
GraphRenderer renderer = new GraphRenderer(graph);
renderer.CalculateLayout();
int width = 1000;
Bitmap bitmap = new Bitmap(width,
(int)(graph.Height * (width / graph.Width)),
System.Drawing.Imaging.PixelFormat.Format32bppPArgb);
renderer.Render(bitmap);
bitmap.Save("test.png");
}
public void SaveGraphToFile(RulesEngineGraph data, int width, int height, string filename)
{
Graph gleeGraph = CreateGraph(data);
var renderer = new GraphRenderer(gleeGraph);
renderer.CalculateLayout();
var bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb);
renderer.Render(bitmap);
bitmap.Save(filename, ImageFormat.Png);
}
public void SaveGraphToFile(RulesEngine engine, int width, int height, string filename)
{
Graph gleeGraph = CreateGraph(engine);
var renderer = new GraphRenderer(gleeGraph);
renderer.CalculateLayout();
var bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb);
renderer.Render(bitmap);
Trace.WriteLine("Saving graph to " + filename);
bitmap.Save(filename, ImageFormat.Png);
}
private void DrawPreviewAutomata()
{
if (WindowState == FormWindowState.Minimized)
{
return;
}
var graph = new AutomataGraph(Automata);
try
{
if (SourceStateIdComboBox.SelectedIndex == -1 || TargetStateIdComboBox.SelectedIndex == -1)
{
return;
}
var sourceDrawingState = graph.FindNode(SourceStateIdComboBox.SelectedItem as string) as State;
var targetDrawingState = graph.FindNode(TargetStateIdComboBox.SelectedItem as string) as State;
var transition = ConstructTransition(sourceDrawingState.LogicState.Id, targetDrawingState.LogicState.Id);
var edge = new Edge(sourceDrawingState, targetDrawingState, transition);
graph.SetupEdge(edge);
edge.Attr.Color = edge.Label.FontColor = MsaglColor.Blue;
graph.AddPrecalculatedEdge(edge);
ErrorLabel.Text = "";
}
catch
{
ErrorLabel.Text = "A megadott szimbólum nem elérhető az ábécében!";
}
var renderer = new GraphRenderer(graph);
renderer.CalculateLayout();
using (var graphics = DrawPanel.CreateGraphics())
{
graphics.SmoothingMode = SmoothingMode.HighQuality;
graphics.TextRenderingHint = TextRenderingHint.AntiAliasGridFit;
graphics.CompositingQuality = CompositingQuality.HighQuality;
graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
renderer.Render(graphics, 0, 0, DrawPanel.Width, DrawPanel.Height);
}
}
private void PrepareForOutput(Graph graph)
{
graph.LayoutAlgorithmSettings = PickLayoutAlgorithmSettings(graph.EdgeCount, graph.NodeCount);
if (argsParser.OptionIsUsed(NoArrowheads))
{
RemoveArrowheadsFromGraph(graph);
}
EnlargeLabelMargins(graph);
SetConsolasFontAndSize(graph, 13);
// rendering
var renderer = new GraphRenderer(graph);
renderer.CalculateLayout();
SetBoxRadiuses(graph);
}
public void SaveGraphAsImage(string path, List <Edge> edges)
{
Graph tmp = CreateGraph(edges);
GraphRenderer graphRenderer = new GraphRenderer(tmp);
GraphRenderer renderer = new GraphRenderer(tmp);
renderer.CalculateLayout();
int width = 1000;
Bitmap bitmap = new Bitmap(width, (int)(tmp.Height * (width / tmp.Width)), PixelFormat.Format32bppPArgb);
renderer.Render(bitmap);
bitmap.Save(path);
}
public string SaveGraphAsImg(string path)
{
Graph tmp = Draw();
GraphRenderer renderer = new GraphRenderer(tmp);
renderer.CalculateLayout();
Bitmap bitmap = new Bitmap(WIDTH, (int)(tmp.Height * (WIDTH / tmp.Width)), PixelFormat.Format32bppPArgb);
renderer.Render(bitmap);
string name = path + Guid.NewGuid().ToString() + @".jpg";
bitmap.Save(name);
bitmap.Dispose();
return(name);
}
static void DrawGraphLayout(CspModel model)
{
var graph = new Graph();
var createdEdges = new List <string>();
//graph.Directed = true;
graph.Attr.SimpleStretch = false;
//graph.LayoutAlgorithmSettings.PackingMethod = Microsoft.Msagl.Core.Layout.PackingMethod.Compact;
//graph.LayoutAlgorithmSettings.EdgeRoutingSettings.Padding = 10;
foreach (var variable in model.Variables)
{
var n = graph.AddNode($"{variable.Name}={variable.Value}");
if (variable.Value == -1)
{
n.Attr.FillColor = Color.Yellow;
}
n.Attr.Shape = Shape.Box;
foreach (var constraint in model.Constraints.Where(c => c.GetVariables().Any(v => v.GetVariable().Name == variable.Name)))
{
graph.AddNode(constraint.ToString());
graph.AddEdge(variable.Name + "=" + variable.Value, constraint.ToString());
foreach (var target in constraint.GetVariables())
{
if (target.GetVariable().Name != variable.Name)
{
if (!createdEdges.Contains(constraint.ToString() + "->" + target.GetVariable().Name))
{
graph.AddNode(target.GetVariable().Name + "=" + target.GetVariable().Value);
graph.AddEdge(constraint.ToString(), target.GetVariable().Name + "=" + target.GetVariable().Value);
createdEdges.Add(constraint.ToString() + "->" + target.GetVariable().Name);
}
}
}
}
}
graph.CreateGeometryGraph();
var renderer = new GraphRenderer(graph);
int width = 600;
int height = 600;
var bitmap = new System.Drawing.Bitmap(width, height, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
renderer.CalculateLayout();
renderer.Render(bitmap);
bitmap.Save("graph.bmp");
}
private void DrawPreviewAutomata()
{
if (WindowState == FormWindowState.Minimized)
{
return;
}
var graph = new AutomataGraph(Automata);
if (Automata.GetState(StateIdTextBox.Text) != null)
{
return;
}
if (StateIdTextBox.Text.Length > 0)
{
var state = new State(ConstructState());
state.Attr.Color = MsaglColor.Blue;
state.Label.FontColor = MsaglColor.Blue;
var startState = Automata.GetStartState();
if (state.IsStartState && startState != null)
{
var oldStartState = graph.FindNode(startState.Id) as State;
oldStartState.OverrideIsStartState = false;
}
graph.SetupState(state);
graph.AddNode(state);
}
var renderer = new GraphRenderer(graph);
renderer.CalculateLayout();
using (var graphics = DrawPanel.CreateGraphics())
{
graphics.SmoothingMode = SmoothingMode.HighQuality;
graphics.TextRenderingHint = TextRenderingHint.AntiAliasGridFit;
graphics.CompositingQuality = CompositingQuality.HighQuality;
graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
renderer.Render(graphics, 0, 0, DrawPanel.Width, DrawPanel.Height);
}
}
/// <summary>
/// Generate an image based on our configuration
/// </summary>
public void Generate()
{
if (mBuildFiles.Count == 0)
{
throw new InvalidOperationException(
"No Build files specified");
}
if (string.IsNullOrEmpty(mOutputFile))
{
mOutputFile
= Path.ChangeExtension(
mBuildFiles.First(),
".png");
}
var projects
= mBuildFiles.Select(f => LoadNAntProject(f))
.ToList();
Console.WriteLine("Generating Graph");
var renderer = new GraphRenderer(mShowDescriptions, mFontName, mFontSize);
Image graph = renderer.Render(projects);
if (graph != null)
{
Console.WriteLine("Saving graph image to {0}", mOutputFile);
graph.Save(mOutputFile);
}
else
{
Console.WriteLine("Failed to generate image.");
}
if (!string.IsNullOrEmpty(mDotFile))
{
Console.WriteLine("Saving dot script file to {0}", mDotFile);
using (var dotFile = new FileStream(mDotFile, FileMode.Create))
{
using (var writer = new StreamWriter(dotFile))
{
writer.Write(renderer.DotScript);
}
dotFile.Close();
}
}
}
void OnGUI()
{
GUILayout.BeginVertical();
DoToolbar();
if (m_CurrentGraph == null)
return;
if (m_Renderer == null)
m_Renderer = new GraphRenderer();
GUILayout.EndVertical();
var graphRect = new Rect(0, k_ToolbarHeight, position.width, position.height - k_ToolbarHeight);
if (m_Layout != null)
m_Renderer.Draw(m_Layout, graphRect);
}
public static void saveGleeGraphAsImage(String sPathToImage, Graph gGraph)
{
//String sImagePath = config.getTempFileNameInO2TempDirectory() + ".png";// System.IO.Path.Combine(DI.config.O2TempDir, "test.png");
// Saving map
var grGraphRendere = new GraphRenderer(gGraph);
int iWidth = 1024;
int iHeight = 1024;
grGraphRendere.CalculateLayout();
iWidth = (int) gGraph.Width;
iHeight = (int) gGraph.Height;
// DI.log.debug("Width: {0} , Height: {1}", iWidth.ToString(), iHeight.ToString());
//Bitmap bitmap = new Bitmap(width, (int)(gGraph.Height * (width / gGraph.Width)),System.Drawing.Imaging.PixelFormat.Format32bppPArgb);
var bitmap = new Bitmap(iWidth, iHeight, PixelFormat.Format32bppPArgb);
grGraphRendere.Render(bitmap);
bitmap.Save(sPathToImage);
// DI.log.debug("GLEE graph saved as bitmap image to: {0}", sPathToImage);
}
