Vectornaut
b92be312e8
This PR adds code for a Julia-language prototype of a configuration solver, in the `engine-proto` folder. It uses Julia version 1.10.0. ### Approaches Development of this PR tried two broad approaches to the constraint geometry problem. Each one suggested various solution techniques. The Gram matrix approach, with the low-rank factorization technique, seems the most promising. - **Algebraic** *(In the `alg-test` subfolder).* Write the constraints as polynomials in the inversive coordinates of the elements, and use computational algebraic geometry techniques to solve the resulting system. We tried the following techniques. - **Gröbner bases** *(`Engine.Algebraic.jl`).* Symbolic. Find a Gröbner basis for the ideal generated by the constraint equations. Information about the solution variety, like its codimension, is then relatively easy to extract. - **Homotopy continuation** *(`Engine.Numerical.jl`).* Numerical. Cut the solution set along a random hyperplane to get a generic zero-dimensional slice, and then use a fancy homotopy technique to approximate the points in that slice. A few notes about our experiences can be found on the [engine prototype](wiki/Engine-prototype) wiki page. - **Gram matrix** *(in the `gram-test` subfolder).* A construction is described completely, up to conformal transformations, by the Gram matrix of the vectors representing its elements. Express the constraints as fixed entries of the Gram matrix, and use numerical linear algebra techniques to find a list of vectors whose Gram matrix fits the bill. We tried the following techniques. - **LDL decomposition** *(`gram-test.sage`, `gram-test.jl`, `overlap-test.jl`).* Find a cluster of up to five elements whose Gram matrix is completely filled in by the constraints. Use LDL decomposition to find a list of vectors with that Gram matrix. This technique can be made algebraic, as seen in `overlap-test.jl`. - **Low-rank factorization** *(source files listed in findings section).* Write down a quadratic loss function that says how far a set of vectors is from meeting the Gram matrix constraints. Use a smooth optimization technique like Newton's method or gradient descent to find a zero of the loss function. In addition to the polished prototype described in the results section, we have an early prototype using an off-the-shelf factorization package (`low-rank-test.jl`) and an visualization of the loss function landscape near global minima (`basin-shapes.jl`). The [Gram matrix parameterization](wiki/Gram-matrix-parameterization) wiki page contains detailed notes on this approach. ### Findings With the algebraic approach, we hit a performance wall pretty quickly as our constructions grew. It was often hard to find real solutions of the polynomial system, since the techniques we use work most naturally in the complex world. With the Gram matrix approach, on the other hand, we could solve interesting problems in acceptably short times using the low-rank factorization technique. We put the optimization routine in its own module (`Engine.jl`) and used it to solve five example problems: - `overlapping-pyramids.jl` - `circles-in-triangle.jl` - `sphere-in-tetrahedron.jl` - `tetrahedron-radius-ratio.jl` - `irisawa-hexlet.jl` We plan to use low-rank factorization of the Gram matrix in our first app prototype. ### Visualizations We used the visualizer in the `ganja-test` folder to visually check our low-rank factorization results. The visualizer runs [Ganja.js](https://enkimute.github.io/ganja.js/) in an Electron app, made with [Blink](https://github.com/JuliaGizmos/Blink.jl). Although Ganja.js makes beautiful pictures under most circumstances, we found two obstacles to using it in production. - It seems to have precision problems with low-curvature spheres. - We couldn't figure out how to customize its clipping and transparency settings, and the default settings often obscure construction details. Co-authored-by: Aaron Fenyes <aaron.fenyes@fareycircles.ooo> Co-authored-by: Glen Whitney <glen@studioinfinity.org> Reviewed-on: #13 Co-authored-by: Vectornaut <vectornaut@nobody@nowhere.net> Co-committed-by: Vectornaut <vectornaut@nobody@nowhere.net>
127 lines
2.7 KiB
Julia
127 lines
2.7 KiB
Julia
using Blink
|
|
using Colors
|
|
|
|
# === utilities ===
|
|
|
|
append_to_head!(w, type, content) = @js w begin
|
|
@var element = document.createElement($type)
|
|
element.appendChild(document.createTextNode($content))
|
|
document.head.appendChild(element)
|
|
end
|
|
|
|
style!(w, stylesheet) = append_to_head!(w, "style", stylesheet)
|
|
|
|
script!(w, code) = append_to_head!(w, "script", code)
|
|
|
|
function add_element!(vec)
|
|
# add element
|
|
full_vec = [0; vec; fill(0, 26)]
|
|
n = @js win elements.push(@new CGA3($full_vec))
|
|
|
|
# generate palette. this is Gadfly's `default_discrete_colors` palette,
|
|
# available under the MIT license
|
|
palette = distinguishable_colors(
|
|
n,
|
|
[LCHab(70, 60, 240)],
|
|
transform = c -> deuteranopic(c, 0.5),
|
|
lchoices = Float64[65, 70, 75, 80],
|
|
cchoices = Float64[0, 50, 60, 70],
|
|
hchoices = range(0, stop=330, length=24)
|
|
)
|
|
palette_packed = [RGB24(c).color for c in palette]
|
|
@js win palette = $palette_packed
|
|
end
|
|
|
|
# === build page ===
|
|
|
|
# create window and open developer console
|
|
win = Window()
|
|
opentools(win)
|
|
|
|
# set stylesheet
|
|
style!(win, """
|
|
body {
|
|
background-color: #ffe0f0;
|
|
}
|
|
|
|
/* needed to keep Ganja canvas from blowing up */
|
|
canvas {
|
|
min-width: 600px;
|
|
max-width: 600px;
|
|
min-height: 600px;
|
|
max-height: 600px;
|
|
}
|
|
""")
|
|
|
|
# load Ganja.js
|
|
loadjs!(win, "https://unpkg.com/ganja.js")
|
|
|
|
# create global functions and variables
|
|
script!(win, """
|
|
// create algebra
|
|
var CGA3 = Algebra(4, 1);
|
|
|
|
// initialize element list and palette
|
|
var elements = [];
|
|
var palette = [];
|
|
|
|
// declare visualization handle
|
|
var graph;
|
|
|
|
// create scene function
|
|
function scene() {
|
|
commands = [];
|
|
for (let n = 0; n < elements.length; ++n) {
|
|
commands.push(palette[n], elements[n]);
|
|
}
|
|
return commands;
|
|
}
|
|
|
|
function flip() {
|
|
let last = elements.length - 1;
|
|
for (let n = 0; n < last; ++n) {
|
|
// reflect
|
|
elements[n] = CGA3.Mul(CGA3.Mul(elements[last], elements[n]), elements[last]);
|
|
|
|
// de-noise
|
|
for (let k = 6; k < elements[n].length; ++k) {
|
|
elements[n][k] = 0;
|
|
}
|
|
}
|
|
requestAnimationFrame(graph.update.bind(graph, scene));
|
|
}
|
|
""")
|
|
|
|
# set up controls
|
|
body!(win, """
|
|
<p><button id="flip-button" onclick="flip()">Flip</button></p>
|
|
""", async = false)
|
|
|
|
# === set up visualization ===
|
|
|
|
# list elements. in the default view, e4 + e5 is the point at infinity
|
|
elements = sqrt(0.5) * BigFloat[
|
|
1 1 -1 -1 0;
|
|
1 -1 1 -1 0;
|
|
1 -1 -1 1 0;
|
|
0 0 0 0 -sqrt(6);
|
|
1 1 1 1 2
|
|
]
|
|
|
|
# load elements
|
|
for vec in eachcol(elements)
|
|
add_element!(vec)
|
|
end
|
|
|
|
# initialize visualization
|
|
@js win begin
|
|
graph = CGA3.graph(
|
|
scene,
|
|
Dict(
|
|
"conformal" => true,
|
|
"gl" => true,
|
|
"grid" => true
|
|
)
|
|
)
|
|
document.body.appendChild(graph)
|
|
end |