What is Reddit's opinion of
Graphviz?
From 3.5 billion Reddit comments
➔ Graphviz website
By popularity on Reddit, this Service is:
82 reviews of this app found across Reddit:
I got onto an Ackermann function kick recently, and was wondering about dependencies. In my definition of dependencies here, looking at the function definition at the top of the Wikipedia article, I have this:
Type I depends on an integer.
Type II depends on one other Ackermann function.
Type III depends on two other Ackermann functions: The inner one that looks like A(m,n-1), and the outer one that is only discovered once the inner one is solved.
In the dependency graphs, Y -> Z means "Y depends on Z". I used Ruby to create a DOT file, and Graphviz to create an image from the DOT file.
From footnote #3 in the original post: >The diagrams here come from the excellent dot tool in graphviz.
I've always ever used GraphViz for my graph-drawing needs. It's got several different programs that do layout in different ways, and I usually find one that works for my dataset. Input is in a pretty simple text file.
I do this kind of things more as a system administrator to display network diagrams and the such, and it's very convenient that a lot of tools out there will output data in the GraphViz text format.
I remade yours using Graphviz. The labels of the edges aren't always ideally positioned. Also, I couldn't figure out how to make the row numbers. Does anyone know a good way?
Edit: The place I uploaded the files to seems to do only short-term storage, so they are gone now, and I have deleted my own copies of them. You'll have to ask OP if you want the source code.
Explanation
Many subreddits dedicated to a country have links in their side bars to their friends and neighbors. This graph visualizes the links between /r/Europe and the 50 countries on the map in our side bar.
Code
This is a bash script.
echo "digraph gb {" > output
for i in cat europelinks;
do
curl https://www.reddit.com$i |sed 's/\n//g' | sed 's/.<div class=\"side\"//' | sed 's/<div class=\"content.//' | sed 's/</\n</g' | sed 's/>/>\n/g' | grep /r/ | sed 's/.\/r\//\/r\//' | sed 's/["& ].//' | sed 's/(\/r\/[^/])./\1/' | tr '[:upper:]' '[:lower:]' | sort | uniq | cat europelinks - | sort | uniq -d | sed 's|^|'"$i"' -> |' | sed "s/(.)( -> )(.)\;/\"\1\"\2\"\3\"\;/" >> output ;
done;
echo "}" > > output
europelinks is a file with all the subreddits
Disclaimer: this script is not literally the code I executed, but more a mash-up of the different commands I think I executed. It's not efficient and probably incorrect
Anyhow, the output should look like this which can be converted into a graph using graphviz.
The thing I spent the most time on was finding an easy to understand program to convert plain text data to a graph. The graphs look a bit dull and messy, but this program was pretty straight forward to use :p
You may find graphviz appropriate, it can produce svg and has a large variety of graph types which may respect your x,y coordinates and do the right thing when drawing lines between nodes, including hops on intersections and avoiding overlap.
Otherwise d3 (javascript) can be used to create the nodes with fixed positions and draw lines between them, but I don't believe it has features for intelligently layout out lines that will automatically avoid overlap or draw hops when they intersect.
"Advice is don't"
I fully agree with this. For a diagram creation, you should use some kind of software which care about diagram structure and you can easily change a process. For example something like this: https://www.draw.io/.
I prefer to use http://www.graphviz.org/. Which is more about programming, i.e. creating diagram by textual command and then it is exported to PDF, PNG or SVG. It is nice when you need to generate diagram with some batch task, but it is difficult to change a visual appearance.
TLDR: Dump a .dot file which describes the chain of events, and visualize it with any viewer (e.g. graphviz)
If you have this organic growth in your events, I'd suggest debugging via writing a graph as-you-go, for example using the dot language. At every chained event, add a node in your graph (could be as simple as a line "event_x -> event_y"). At the end of your frame, you'll have a nice graph, ready for visualization using whatever software, I like graphviz.
i always use graphviz, which is specialized for creating state machines and direct/undirected graphs. it uses the 'dot' format which is also supported by a lot of other tools.
it's free and quite powerful, and can output a load of different formats, ps, eps, pdf, jpg, etc. making it pretty easy to embed in a latex document.
I prefer to use the command-line.
For quick work, I've had very good luck with Graphviz and the "neato" tool.
A graph might look like this:
graph G {
coreIdea -- subthought1; coreIdea -- subthought2; coreIdea -- subthought3;
subthought1 -- anotherIdea; subthought1 -- blaBlaBla; }
Doxygen, hands down (all free and opensource). http://www.stack.nl/~dimitri/doxygen/
You will also need to download GraphViz. http://www.graphviz.org/
This tool will create HTLM and PDF documentation.
Read the release notes, because you need to edit your PATH environment variable to point to the GraphViz executable. The rest is easy.
yEd is entirely Java, and should run on anything with an OpenJDK or a cometing JRE installed, for those wondering. The out of the box shape library should be comforting to users expecting that.
That said, I've been doing a lot of things the non-GUI way by building DOT files for Graphviz off and on for a long time. If you audience expects depictions that rival a glossy Cisco sales brochure, it's not a good choice. If you want to store it in a Git repo, output it from automatic discovery tools that leverage LLDP, or do any kind of automatic processing with it, it could be exactly what you need.
http://www.graphviz.org/ is the perfect tool for visualizing trees/graphs without having to do any manual layout at all (and is free).
EDIT: Look at some great examples here: http://graphs.grevian.org/example (I guess Example 3 is exactly what you need, so just copy that and type in your tech names and you are done).
graphviz tip: you can use <code>label=</code> to change the visual label of a node. a node's name is unique, but labels can be duplicated. with label= you could've removed the 2 from those teams:
graph G { SDP2 [label="SDP"]; SEA2 [label="SEA"]; SEA -- SDP2; CHC -- SEA2; }
I'd probably take the long way and do this:
- Create a makefile to compile everything.
- Create graphs using Dot (and add them to the makefile)
- Edit everything in VIM, generate everything with
:make.
I have a largely text-based office "suite" (read: a bunch of unrelated programs). May or may not be what you want.
For presentations: Reveal.js
For documents: Markdown → HTML (with some CSS I have pre-written for this purpose) → PDF.
For diagrams: GraphViz (dot)
Thankfully, I don't need spreadsheets. If I did, though, I'd head to LibreOffice Calc.
If you use GUI Emacs, you can display images inline.
In org-mode, this is fucking fantastic, for rendering GraphViz and PlantUML.
Org Babel config, dot and plantuml templates and links to docs here: https://github.com/jplindstrom/dotemacs/blob/master/config/mode-org.el#L99
PlantUML in particular has surprised me lately with how complete and useful it is if you have to create basic diagrams and system drawings. It even does basic GUI layouts.
I wrote combinatorgraph for this purpose, but it's not exactly great. It produces a graphviz graph with the configuration of all the combinators.
There's a few projects for HDLs, but none of them are really at a usable point yet.
IMHO the best possible set would be a blueprint, a graph (if it's a decent one...), and a set of annotated screenshots with particular areas/devices you feel deserve comment. Don't bother with configuration in screenshots, that's all in the blueprint and can be studied in-game.
It's kind of low-tech and DIY, but I really love graphviz for creating complex process flow diagrams because it automatically does the layout for me and I can make changes to a text file with ease. You can export to html too. http://www.graphviz.org/Gallery.php
The black lines are for assemblers, the red lines are for boilers, the blue lines are for chemical plants, the purple lines are for oil refineries, the orange lines are for steel/stone furnaces, the yellow lines are for electric furnaces, and the green lines are for centrifuges.
These images were made in GraphViz, which is an open-source graphing software, generally used for diagramming object dependencies. It generates these graphs based on code I've written in their markup language, and can generate graphs based on different algorithms. I've used two algorithms to make a set of graphs, DOT which creates hierarchical graphs, and FDP which creates less directional ones (More info in the Imgur album). Let me know if you want to see this in any other algorithms, have a different setup, or want to get at the code yourself.
EDIT: Added two more algorithms here!
I've used Draw.io in the past, and it works pretty well. It's web-based and syncs with various cloud file services.
If you'd rather have a desktop program, yEd looks pretty good. And if that's not old-school enough for you, the OG of flowchart software is Graphviz, which lets you write your flowcharts in a text markup language. I've tried it and it was like pulling teeth, but I imagine that if you do this for a living, you could get really good at it.
Thanks, I appreciate that!
edit: Just want to clarify, the graphics itself is generated by Graphviz, which is an awesome program. According to their credits page it appears that it was developed by AT&T.
The visualization is a directed acyclic graph (DAG) with arrows going from thesis advisor to PhD recipient. To follow reddit's rules about personal information, I censored the most recent links in the graph (including my own name).
Data generated using David Alber's Geneagrapher 0.2.2-r2 and visualized using graphviz-2.38.0. Data gathered from the Mathematical Genealogy Project.
edit: Also sorry about the jpg quality...I tried to strike a balance between not too large of a file and readability of the names. The original pdf is very clear, but I had trouble getting imgur to upload the pdf in its full quality.
I've made something like that for my own use. It gets impractical if you want to go more than 30 levels up; the combinatorial explosion just kills you.
For reference, these are the optimizations I applied:
- remove nodes that have a score of 0 and don't link to any other node
- remove nodes that have a score of 0 and link to exactly two nodes, collapsing the connection
- remove connections that run in parallel to other connections in such a way that they'll never be the preferred link. (This one is complicated and I don't really understand it myself anymore.)
Also note that a lot of speed could potentially be gained by avoiding doublechecking trees that have already been checked. (For instance, using some sort of hashing approach)
The best approach I've found for finding optimizations is dumping the optimized node graph and generating a layout with graphviz, then looking at optimizations you would make yourself.
For instance, here is the optimized graph for "increased Attack Speed" starting as Ranger: link.
I haven't been able to make it usable beyond 30 levels though - it goes from seconds to minutes very quickly.
Good luck with yours!
Sounds like such a utility should use Graphviz as a backend. While it doesn't provide the pretty diagram that's expected in network diagrams, it does do network diagrams using the graph abstraction.
Graphviz can also be used to create ERDs, though my favorite is still MySQL Workbench. The only downfall I see with it, though it's completely understandable, is that it's only forward/reverse engineers MySQL. However, to me that's minor since it does everything else nicely.
I believe a lot depends on what's required to draw the map mathematically, and which method is used. If you look at the Graphviz website, it supports many methods to create graphs, and can handle quite large maps if the right method and combination of code is used. Just a browse through their documentation shows some examples of how it can be done, but most of it is way over my head.
I suspect the difference in how one type of graph in Gramps does work and another doesn't has to do with who wrote the code, and their knowledge of Graphiz. Again, according to their website, it can handle pretty large graphs, as long as one uses the right method and send it properly formatted data. I believe Gramps can be scaled up, but it would require knowledge of the different Graphiz methods, and some plugin code rewriting to take advantage of those methods.
As to removing the ellipses, I'm sure it's possible, but currently I have no idea how. I've only recently started dabbling with code, since I retired. I've always been curious on how all this works, now that I have the time I've been exploring it. However my present knowledge is woefully inadequate for that.
Any reason why people do not like graphviz? There are Haskell bindings in the graphviz package, and a diagrams backend in diagrams-graphviz.
I typically write my source files in Emacs. It can do some basic previewing, but I'm guessing you'd prefer your "good tool" option not to require learning Emacs :-D.
The GraphViz resources page is worth checking out. I haven't tried most of these, but maybe you'll find something you like.
It's really easy to write: gexf.net/format/primer.html and http://gexf.net/1.2draft/gexf-12draft-primer.pdf
Keeping in mind that this code appears long but only because creating XML is a seriously wordy experience in java: http://pastebin.com/WbijCQHF
The beauty of that, though, is that you can shove whatever attributes you like into your nodes and edges, and gephi will do something useful with it.
If you "just want to show a damn graph with nodes and edges" and don't want to deal with java's xml faffery, graphviz's "dot" format is trivial: http://www.graphviz.org/Gallery.php - gephi can also read dot format
Add a printout to the beginning of the function that outputs a node in dot syntax (see link below) and add printouts before the recursie calls to output edges and then use graphviz to visualize. This is a) automated so you can try different recursions and b) you don't have to think about the layout beforehand because graphviz is doing thale hard part for you. http://www.graphviz.org/Documentation.php
Do you really want to build this algorithm yourself, or are you just looking for a simple way to accomplish this task?
If it's the latter, look into graphviz: http://www.graphviz.org/
All you have to do is output a text file in the DOT language, which is really easy (it's basically a list of nodes and a list of edges): http://www.graphviz.org/content/dot-language
That's graphviz, also sometimes called "dot".
Here's the .dot file where I wrote down the relationships between those things:
digraph G { rankdir="TB" pip -> nodeenv nodeenv -> npm npm -> {"react-tools" bower "uglify.js"} bower -> {"react.js" reconnectingWebSocket TodoMVC superagent} {"react-tools" "react components JSX" } -> "react components JS" {"uglify.js" "react components JS" "todoModel.js"} -> "compiled.js" subgraph cluster_browser { "react.js"; reconnectingWebSocket; TodoMVC; superagent; "compiled.js"; label = "In browser" } subgraph cluster_my_code { "react components JSX" "todoModel.js" label = "My code" } }
If you save that as "makefile.dot", you can generate a PNG like the one in my slides with this command:
dot -Tpng -omakefile.png makefile.dot
EDIT: reduced whitespace
Note that i wrote this stuff here implementing the idea of taking over require and recording/limiting what is available.
It is still experimental, eventually i'll apply it on my code. Maybe make some graphs using <code>dot</code>.
I do think that in principle, you can do crazy stuff, like taking one of the files, and saying "this runs on this other server".
I rendered the graph using the nice Graphviz package, there's no (simple) way of controlling the placement of individual nodes/edges.
There's a .svg version of the image in my GIT repository.
Hmm.... maybe Gephi or GraphViz? There's several Graph visualizers out there so it's hard to say.
I love graph visualizations like this but i confess I'm not very good at making them. It takes both sides of the brain to make something both visually interesting and also informative. The gator graph above looks neat but doesn't say much (at least to me). But the people who made these ship log visualizations really nailed it.
There's nothing that will do this for you automatically. I would suggest to go with what /u/bossier330 said: turn on Verbose logging for your DB layer (or manually log things you'd like to track, to a predictable record structure), then use something like: http://d3js.org/ or http://www.graphviz.org/ to do the actual image generation for you.
You also should think about what you're looking to map: query execution time, number of times a query is run, number of queries per request, amount of data returned per query, etc.
All of this may be fed into a force directed graph layout or something fancy like that. Good luck! Sounds like fun :)
It depends what I'm working on, but mostly I use a template I created that provides me a framework to understand what the entities are, and Graphviz for initial layout. Sometimes I use the dot program (as I did with the megadungeon), other times I use the neato program (as with the Keys of Heraka-at) scenario.
If you don't mind putting some learning time in, Graphviz is an incredibly flexible and powerful tool. You use a simple language to create charts that consist of nodes and connections, and then you have a variety of options as to how they should be laid out.
Here's a chart I made of precedent in my federal jurisdiction class. As I briefed cases throughout the semester, I'd note any cases they cited which were also in the materials. You can see my briefs here-- if you view the HTML source for any of them, you can see the citations in a comment field at the bottom. When the semester ended, I just used a little program I had written to describe all cases as nodes (brown is state, blue is federal, blue octagons are SCOTUS), describe lines between them representing the citations, and align them vertically based on date. Then render with the "dot" tool in Graphviz.
Yes, I am kind of letting my nerd flag fly.
Anyway, the point is that with Graphviz, you can do pretty much any flowchart you might care to (as long as you are not real verbose with the contents of the shapes), and changes later are trivial: just edit a text file and regenerate the chart.
It's not a perfect tool-- if you're trying to make camera-ready stuff for publication, if you don't want to invest time in learning how to work it, or if you need fine-grained control over layout, you probably want something else. But the price is right ($0), it runs on Windows, Mac, or Linux, and it makes it so that all you have to do is create a text file that describes the chart: Graphviz does the actual drawing for you.
I generally use Graphviz.
What I typically do is programmatically generate (or write) a file which might look something like this:
digraph flat { node [shape=box style="filled" penwidth=0 fontcolor="#ffffff" fontname="Segoe UI" width=2.2 height=0.52] edge [arrowhead="open" color="#505050"]
node0 [label="table: FLIGHTS" color="#ff8c00"];
node1 [label="where" color="#8cc600" width=1]; node0 -> node1;
node2 [label="and" color="#8cc600" width=1]; node1 -> node2;
node3 [label="terminal op: FROM" color="#00aeef"]; node2 -> node3;
node4 [label="city name: BALTIMORE" color="#910091"]; node3 -> node4;
node5 [label="terminal op: TO" color="#00aeef"]; node2 -> node5;
node6 [label="city name: DALLAS" color="#910091"]; node5 -> node6;
node7 [label="terminal op: ARRIVING" color="#00aeef"]; node2 -> node7;
node8 [label="date: 3/14/96" color="#910091"]; node7 -> node8;
}
...then generate a png file using Graphviz that looks like this:
Graphviz is a standalone program which you run from the console, but there are bindings/libraries in several different programming languages you can use. Personally though, I prefer hand-generating the .dot files -- the syntax for them is really simple, and it's easier for me to just concat strings and create the file rather then trying to figure out how to use whatever library they recommend.
I've only ever generated png files, but I think Graphviz should support SVG or EPS -- here's a list of supported output formats.
Thanks! I think it will NOT conflict with vim-pandoc since it doesn't do anything else than live preview. I myself use vim-pandoc-syntax and vim-pandoc-after and set "au BufNewFile,BufRead *.md set filetype=pandoc". The dot is generated with graphviz, use google to see many other examples. It is a "have to" / killer app if you have to create graphs. :-)
Yes, graphviz comes as library. You create the .dot file in memory, pass it through "dot", get a modified structure back, then read attributes from the nodes. See http://www.graphviz.org/doc/libguide/libguide.pdf
Making pictures of graphs, including vertex-colored graphs, is built in to Mathematica. Since you're at a University, I assume that you have access to Mma.
Or, if you want to completely avoid proprietary software, you can generate text files to be read in by dot, which allows you to make almost any graph you want.
GraphViz should be able to do the job, you describe the dependencies via a simple text file and it will generate a graph for you.
For something more graphical and clicky, you could try Dia.
Yes, a flow diagram is about right. Programmers write code more than visual documentation like that, but yes, sure, sometimes Visio. I don't know whether there is any tool (free at least) that will automatically extract flow from code. Programmers write plain text sometimes, for test plans.
There's 'dia' that's free software, some of the f'nality of Visio, and 'dot' (part of www.graphviz.org) to generate any kind of graph, from text, if Visio is unavailable.
Actually 'dot' has the advantage that it's declarative (ie you specify the connections, and let it lay the graph out, good for when the graph is very complex); and, text-editable (letting you use all the power of a good text editor), and you can change how the resulting graph is displayed with relatively little hand editing. You can annotate the nodes and edges...
What you are describing is a little more than many stock programs will do. Clarification of whether or not this is something that is supposed to be in a web browser or not would also be very useful.
You can make a very pretty tree with dot. It is part of the graphviz package. Wikipedia page is actually pretty good with code examples and output examples: http://en.wikipedia.org/wiki/DOT_language
*Lazarus plugin for browsers (backs up text typed into webpages)
*Z shell (much better than bash)
*MacPorts (Ports of Unix/Linux apps for OS X)
*ccache (C/C++ compiler cache)
*Skim (PDF Annotator for OS X)
*Macfusion (mount filesystems over ssh). Sshfs for other OS's.
*Graphviz (automatic graph layout)
*Synergy-plus (One mouse, multiple machines)
Not quite sure if I got the question right, but you can try dot (from the graphviz package). I believe there is a "front-end compiler" for it that runs on OS X.
You can also install it with MacPorts.
http://www.graphviz.org/ might be what you are looking for... you can create the DOT language directly in python, or use one of the python bindings for graphviz. I have not used any of the python bindings - but a search revealed a number of them.
imho the best thing they could do is just implement graphviz.
The same way they added math mode with LateX, they could add "graph mode", where you can make charts by just typing in dot language. With its libraries it should not be hard.
LibreNMS/Observium have enough information in their database to do it, but Observium has no UI for it, and LibreNMS only does L2 (and badly). I wrote a script to pull that data, associate /31 and /30 networks by bitwise math and spit out a GraphViz source file (complete with line width for link speed and a green->yellow->red transition for throughput. For ECMP OSPF leaf/spine it works pretty well.
If you wanted to do it without adding another tool, with single entry point (with SNMP globally enabled, in theory any switch's IP address), and just poll outwards, adding any discovered neighbours to the list to poll as you go. The IPv4 routing table is at 1.3.6.1.2.1.4.24.4.1.4 and the local interface/masks at 1.3.6.1.2.1.4.20.1.3, which might be a good starting point to finding information.
Just be prepared too for it to get messy if you've got a large network, I've got about 250 /31 routes displayed in the resulting chart and I have trouble making it legible on a 1080p display.
Even if you use Python, you are still going to need to use a toolkit (TkInter/Gtk+/Qt/WxWidgets) to implement the GUI. Since you already know C++, I would recommend you use Qt. It has excellent documentation and there are tutorials for pretty much everything including hello world.
That being said, the solution that came to me from your requirements is Graphviz. It uses a DSL (the dot language) to create graphs like you are describing. It also looks like there is a library (cgraph) that you can use in your program.
Graphviz is my go-to when all I want is a boxes-and-arrows drawing so I can just see how things are connected (this is most of the time). The default layout engine (dot) is tops at showing hierarchy.
PlantUML is what I reach for when I want to do UML-style stuff, which isn't too often honestly. But the sequence diagrams are good, and I've used the wireframe tool as well.
Since they're both text-based, the drawings are easy to write, version, and even auto-generate programmatically. Here's someone that put Wireshark and PlantUML together to see what their network traffic looks like, and somewhere in the void is a script I wrote (and lost) that generated the call graph of some lisp source.
I have used Graphviz, a free - open source graphing language you can use from the command line. It's very powerful, but not a visual program. you "program" your graph, and this software renders it. check it out http://www.graphviz.org/.
You can use Graphviz for systems based program.
http://www.graphviz.org/Gallery.php
Else you can use D3 if you want web based one.
https://bl.ocks.org/mbostock/4062045
http://orgo.stolarsky.com/ (Using D3)
Kinda feel like I'm talking to myself :P But in case someone happens upon this, I found a great little program: http://www.graphviz.org/
There's even a web version here: http://www.webgraphviz.com/
What about GraphViz?
- Free and open source
- No real need for "templates" since it's built to visualize graphs, including DAGs
- Layout is mostly automatic
- Plus as a bonus, its input files are plain text so you can version them easily
You can, in principle. However, it isn't designed for that sort of thing, so it won't be as easy as packages that are designed for that. The graphviz tool seems to be the main one, and it has various python interfaces, such as pygraphviz and graphviz.
I would do something scripted (similar to, or as an extension to, my tool gamebookformat) that output a dot-file for GraphViz. That is a free and very simple way to make graphs from text input without having to manually layout things (you can set various flags/options if you want to control how it lays out the nodes; I usually just use the defaults).
From gamebookformat I just export the section-numbers when making graphs, but you could of course instead put the entire text into it. You might be able to get that by just slightly modifying the dot-templates included in gamebookformat actually, so it would be very little work, or you could even manually type the text into a text-document in the correct dot-format (which is not very difficult and there are several tutorials easy to find on google).
Tu as graphviz qui permet de générer des graphes. Tu as un fichier texte à préparer pour les données sur le graphe et avec une ligne de commande ça te génère le dessin.
Exemples de ce que tu peux faire en visant un arbre généalogique. Tu dois pouvoir trouver des templates facilement.
RealtimeBoard for general brainstorming.
Graphviz Dot for developing the plot, keeping track of characters, places and points in time.
Both are free.
It might be overkill, but for drawing graphs you could have a look at Graphviz.
It uses a text-based description of an graph and automatically aligns nodes an edges. It works very good, even for huge graphs.
Have a look at this link for neural networks: https://tgmstat.wordpress.com/2013/06/12/draw-neural-network-diagrams-graphviz/
That all depends on the code of the program you're compiling to EXE. Regardless, if you want to plot a graph, write a C program that calls Graphviz, which is a program you could bundle with yours and would actually plot a graph into any number of file formats for you. http://www.graphviz.org/
I mean, if you have to have it as an EXE, that is. If you want EXEs, Python isn't really the programming language for you.
Back when we had to do heaps with pointers, I gave each node in the tree a unique ID and then printed out the pointers using graphviz. This way you could easily see if any pointers were pointing incorrectly.
> how is it possible that they simply kept rearranging until there were no lines forced to cross eachother or swoop around even a small portion of the graph?
I would guess that the graph was constructed using something like Graphviz, which automatically tries to find the optimal layout with the shortest paths and least number of crossings.
The script generates a dot graph that I just copy/paste into the program Graphviz (using the 'neato' renderer). I've got plans for modifying the script once I get back from holiday vacation (next Tuesday) -- I'll update the list of locations, and explicitly put a list of excluded places in there (eg. places with permit required) and filter port distance < 1000 ls like I'm doing manually now, so it will be clear that the stations are excluded for a reason. Nobody wants to wait to travel 600000 ls; ain't nobody got time fo' 'dat.
Further, the big change I've been mulling over, is instead of picking the result with the largest minimum sell distance, to add average tons to the data & calculated expected profit ratio, given the distance. That way I'll be able to short-circuit the issue directly and choose the route that yields the most cargo at the best profit-distance.
Depending on what exactly you want, it is very easy to generate graphviz .dot files, from which you can then generate pictures, and not entirely trivial, but reasonably simple to draw trees with diagrams.
And of course you can always do the trusty ASCII graphics (I guess that's your original question?). It's again not completely trivial, but a good exercise to write it yourself. One way is to always work with rectangular blocks, and connect them recursively.
If you can convert features between two rows into a measure of difference you can use Multidimensional Scaling. It attempts to find euclidean points in 2D (or really any euclidean dimension) such that the distances are preserved as well as possible. Its good if youre mainly interested in visualization. Graphviz neato can pretty much do it for you: http://www.graphviz.org/pdf/neatoguide.pdf
Well, this may not be what you're looking for, but Graphviz is language agnostic. A graph is specified by a text-based configuration (one of many formats, including DOT) that you could pass to graphviz by calling the process. I'm not familiar with C, but it looks like there is a C library for working with it directly.
So, for a basic exercise, I'd probably draw the lines with GL_LINES and the circles (assuming they don't have to change size much or support many colors) with a textured quad, as has been suggested.
In production if I were building a game like this, I'd use something like GraphViz (possibly with their Smyrna codebase http://www.graphviz.org/pdf/smyrna.pdf ) to draw the graphics as it's suited for lots more styles of graphs.
Alternately, I often use Cairo (via osgCairo in my OpenSceneGraphOpenGL applications) to do this sort of graphics. It's LOVELY. You can basically rasterize stuff like this to a texture and then just blit the texture to the screen on a textured quad: http://cairographics.org/OpenGL/
But that's not really what your assignment is trying to teach.
Finally NVidia has a really cool 2D path stroke extension: https://developer.nvidia.com/sites/default/files/akamai/gamedev/files/nvpr_annex.pdf
that is great for drawing line/fill 2d structured graphics directly on the GPU. But again, outside the scope of your assignment, I'm just mentioning it for the benfit of others who might come across this question.
One of the popular software for making graph diagrams is http://www.graphviz.org/. It's rather easy to dump relationships from your data into .dot file format for graphviz to interpret.
The mind map thing is computed by pydot, a Python wrapper for Graphwiz. I hope to eventually integrate the Javascript port of Graphwiz as it would enable much richer UI controls. Unfortunately that port doesn't appear to be entirely stable. Mañana...
I use the open-source GraphViz—it can automatically construct a chart based on a text file with lines like "'Event A' -> 'Event B'". Here’s a sample of one that I’m working on—the gray boxes are dates, and my text file just specifies the order in which events occur relative to particular dates and to each other. GraphViz does the layout automatically, and rearranges everything as needed whenever I update the source file.
Cool code! If you're looking for feedback:
- I bet you can reduce the running time for dense graphs by using a different algorithm for sampling without replacement
- It shouldn't be too hard to add an output format accepted by Graphviz - so you can see the graph you generate.
i'll put it on my random things docket. i don't feel interested enough in the subject material, but i guess i've already invested some thought in the concept, and making a burton thing would at least be more productive they simply redoing the coen one. it's certainly a significant dataset. i would probably approach this by first using processing or graphviz to do some rapid prototyping of layouts possibilities. or i would if my coding wasn't so rusty. maybe i should do this. i'll let you know if i do.