Creating nodes procedurally (and visualizing them)

Question

I am looking for an algorithm that provides a way to generate graphical representations of nodes (either 2D or 3D, but the first, with vector graphics, is preferable).

I have seen many references to node theory in general, encompassing punctual references to general information .

Before trying to develop something from scratch on my own, I would like to learn about the existence of any existing software that allows you to not only represent them (in memory), but also visualize them in some of its graphical representations (there are many ). It can be presented in the form of a library or a simple function or even a pseudo-code algorithm that tries to indicate how to correctly display information on the screen.

As the previous link shows, Wolfram Mathematica has a package called KnotTheory that does this (almost completely). However, it is not portable, nor free software and access to its modules will be very cumbersome for me (free implementation in Java, just to name the language, but every language is fine, would be ideal in terms of mobility and openness) .

I saw that many software tools are available (but most of them are old and inaccessible or usable). Do you have any good recommendations?

UPDATE : Since two voices appeared to close this question, I retell it in a more pragmatic and understandable way: are there algorithms for drawing and creating nodes? something is already implemented

UPDATE 2 (for reopening) The graphic representation can be a three-dimensional rendered object or svg 2D graphics (I digress from it, because I look at the programming language as a processing (or the same Mathematica) that provides you with primitives for drawing curves (splines, beziers, etc.) on the screen (and then export them to bitmap or vector graphics). The algorithm should accept parameterization on one node as input (i.e. if we are talking about nodes described by their intersection properties , their meanings are what is needed), returning one of the graphical representations above (that is, even a sequence of points in a 2d space), that is, any parameterization is beautiful, my goal is simply to get an introspection on how to draw nodes to get ONE algorithm which does this in a certain way, leading to a specific view, would be fine (Mathematica lib seems to be able to draw it in a variety of views).

Answer 1

Something like that?

 void setup() { size(300, 300, P3D); } void draw() { background(36, 10, 28); int f = frameCount%360; translate(width/2, height/2); if (frameCount >= 360 && frameCount <= 1080 ) rotateY(radians(f)); stroke(0); drawKnot(40); translate(knotX(f)*40, knotY(f)*40, knotZ(f)*40); noStroke(); fill(180,50,145); sphere(10); } void drawKnot(float sz) { stroke(200); for (int i = 0; i < 360; i++) { point(knotX(i)*sz, knotY(i)*sz, knotZ(i)*sz); } } float knotX(int n) { return sin(radians(n)) + 2*sin(radians(n*2)); } float knotY(int n) { return cos(radians(n)) - 2*cos(radians(n*2)); } float knotZ(int n) { return sin(radians(n*3))*-1; } 

Answer 2

Wolfram Mathematica has a basic node theory, including visualization, built-in:

http://reference.wolfram.com/language/ref/KnotData.html

This software documentation web page contains many examples of standard node-theoretic visualization and computations that can be performed using Mathematica.