Sometimes there are projects that we introduce with a bit of context, some background, and other times as with [RayP2]’s fractal papercraft tree, we introduce them simply because they are beautiful.
It’s a deceptively simple design of a repeating pattern of the same shape getting ever smaller with each iteration, and terminating in a tetrahedron with branches from each of its faces. It’s not origami, instead it’s a cut-and-glue design, and its construction is a surprisingly involved affair with some lateral thinking required to bend the tabs on the smaller branches. The design was first prototyped with plain paper, before a final version was made with card stock. The part that makes it exceptional is that he used shiny gold card stock with the gold side on the inside, meaning that when lit from the trunk the end of each branch glows attractively. Fitting the light required a modification to the trunk design, but this doesn’t take away from the whole.
The result is an attractive sculpture, a talking point, and something with a mathematical angle to boot, which we like. It’s certainly not been the first papercraft ptoject we’ve shown you, though perhaps these paper retrocomputers are a little less artistic.
The mesmerizing properties of fractals are surprising as their visual complexity often arises from simple equations. [CodeParade] set out to show how simple a fractal is by creating them using technology from the 1930s. The basic idea is based on projectors and cameras, which were both readily available and widely used in television (CRT projectors were in theaters by 1938, though they weren’t in color until the 1950s).
By projecting two overlapping images on the wall, pointing a camera at the resulting image, and then feeding it back into the projectors, you get some beautiful fractals. [CodeParade] doesn’t have a projector, much less two. So he did what any hacker might do and came up with a clever workaround. He made a simple app that “projects” onto his monitor and all he has to do is point an external webcam at the screen. The resulting analog fractals are quite beautiful and tactile. Rather than tweaking a variable and recompiling, you simply just add a finger or move the camera to introduce new noise that quickly becomes signal.
Better yet, there’s a web version that you can play around with right now. For more fractals implemented in hardware rather than software, there’s this FPGA with a VHDL Mandelbrot set we covered.
Continue reading “Finding Fractals In The 1930’s” →
Have you ever seen something that’s so fascinating you’re sure there has to be some kind of practical application for it, but you just can’t figure out what? That’s how we feel when watching tiny ball bearings assemble themselves into alien-like structures under the influence of high voltage in the latest Plasma Channel video from [Jay Bowles].
Now to be clear, [Jay] isn’t trying to take credit for the idea. He explains that researchers at Stanford University first documented the phenomenon back in 2015, and that his goal was to recreate their initial results as a baseline and go from there. The process is pretty simple: put small metal ball bearings into a tray of oil, apply high voltage, and watch them self-assemble into “wires” that branch out in search of the ground terminal like a plant’s roots looking for water. With the encouragement of his 500,000 volt Van de Graaff generator, the ball bearings leaped into action and created structures just like in the Stanford study.
With the basic pieces now in place, [Jay] starts to push the envelope. He experiments with various oils to see how their viscosity impacts the ball’s ability to assemble, finding that olive oil seems to be the ideal candidate (at least of those he’s tried so far). He also switches up the size and shape of the tray, to try and find how far the balls can realistically stretch out on their own.
In the end we’re no closer to finding a practical application for this wild effect than the good folks at Stanford were back in 2015, but at least we got to watch the little fellows do their thing in glorious 4K and with the exceptional production value we’ve come to expect from Plasma Channel. That said, [Jay] does hint at his ongoing efforts to turn the structures into works of art by “freezing” them with clear resin, so keep your eyes out for that.
Continue reading “High Voltage Gives Metal Balls A Mind Of Their Own” →
The Mandelbrot set is a curious mathematical oddity that, while interesting in its own right, is also a useful tool for benchmarking various types of computers. Its constant computing requirement when zooming in and out on the function, combined with the fact that it can be zoomed indefinitely, means that it takes some quality hardware and software to display it properly. [Thanassis] has made this a pet project of his, running Mandelbrot set visualizations in different ways on many different hardware platforms.
This particular one is based on an STM32 board called the Blue Pill, which [Thanassis] chose because he hadn’t yet done a continuous Mandelbrot zoom on a microcontroller yet. The display is handled by a tiny 16K IPS color screen, and some clever memory tricks had to come into play in order to get smooth video output since the STM has only 20 kB available. The integer multiplication is also tricky on a platform this small while keeping the continuous zoom function, so it’s limited to fixed point multiplication.
Even with the limitations of the platform, he is still able to achieve nearly double-digit FPS rates with this one. If you want to play around with graphics like this on an STM platform, [Thanassis] has released all of the source code on his GitHub page, but if you’d like to see more Mandelbrot manipulation you can check out one of his older projects where he built a similar project on an FPGA.
Continue reading “STM32 Gets Up Close And Personal With Mandelbrot” →
Over on GitHub, [ttsiodras] wanted to learn VHDL. So he started with an algorithm to do Mandelbrot sets and moved it to an FPGA. Because of the speed, he was able to accomplish real-time zooming. You can see a video of the results, below.
The FPGA board is a ZestSC1 that has a relatively old Xilinx Spartan 3 chip onboard. Still, it is plenty powerful enough for a task like this.
Continue reading “FPGA Used VHDL For Fractals” →
Int 1777, Georg Lichtenberg found that discharging high voltage on an insulating surface covered with a powder, a fractal-like image appears, sometimes known as a lightning tree. Incidentally, this is a crude form of xerography, the principle that lets copiers and laser printers operate.
[PaulGetson] had a high voltage power source from his Jacob’s ladder experiments and decide to see if he could create Lichtenberg figures. Turns out, he could.
Continue reading “High-Voltage Fractals” →
This FPGA based build creates an interesting display which reacts to music. [Wancheng’s] Dancing Mandelbrot Set uses an FPGA and some math to generate a controllable fractal display.
The build produces a Mandelbrot Set with colours that are modified by an audio input. The Terasic DE2-115 development board, which hosts a Cyclone IV FPGA, provides all the IO and processing. On the input side, UART or an IR remote can be used to zoom in and out on the display. An audio input maps to the color control, and a VGA output allows for the result to be displayed in real time.
On the FPGA, a custom calculation engine, running at up to 150 MHz, does the math to generate the fractal. A Fast Fourier transform decomposes the audio input into frequencies, which are used to control the colors of the output image.
This build is best explained by watching, so check out the video after the break.
Continue reading “Dancing Mandelbrot Set On A FPGA” →