I recently decided to give a serious go to learning Rust. As my first non-toy project, I decided to port an old piece of code I'd been wanting to dust off anyway: k-d forests. The basic premise of it is to generate images with every possible 8-bit RGB color, by placing each color next to the most similarly-colored pixel placed so far.
Continue reading Porting k-d forests to RustCategory Archives: Computer Science
Cracking DHCE (Diffie-Hellman color exchange)
I recently saw a video that explains Diffie–Hellman key exchange in terms of mixing colors of paint. It's a wonderfully simple and informative analogy, that Wikipedia actually uses as well. If you don't know about Diffie-Hellman, definitely watch the video and/or read the Wikipedia page to get a handle on it—it's not that complicated once you get the "trick." The color analogy intrigued me because I know just enough about both cryptography and color theory to be dangerous. So in this post, I'm going to attack the security of the color exchange protocol. ("Real" Diffie-Hellman remains secure, as far as I know.) Continue reading Cracking DHCE (Diffie-Hellman color exchange)
bfs from the ground up, part 2: parsing
Today is the release of version 1.0 of bfs, a fully-compatible* drop-in replacement for the UNIX find command. I thought this would be a good occasion to write more about its implementation. This post will talk about how I parse the command line. Continue reading bfs from the ground up, part 2: parsing
The Approximating and Eliminating Search Algorithm
Nearest neighbour search is a very natural problem: given a target point and a set of candidates, find the closest candidate to the target. For points in the standard k-dimensional Euclidean space, k-d trees and related data structures offer a good solution. But we're not always so lucky.
Continue reading The Approximating and Eliminating Search AlgorithmFast, Branchless Ray/Bounding Box Intersections, Part 2: NaNs
In part 1, I outlined an algorithm for computing intersections between rays and axis-aligned bounding boxes. The idea to eliminate branches by relying on IEEE 754 floating point properties goes back to Brian Smits in [1], and the implementation was fleshed out by Amy Williams. et al. in [2].
Continue reading Fast, Branchless Ray/Bounding Box Intersections, Part 2: NaNs
Exact Bounding Boxes for Spheres/Ellipsoids
Finding the tightest axis-aligned bounding box for a sphere is trivial: the box extends from the center by the radius in all dimensions. But once the sphere is transformed, finding the minimal bounding box becomes trickier. Rotating a sphere, for example, shouldn't change its bounding box, but naïvely rotating the bounding box will expand it unnecessarily. Luckily there's a trick to computing minimal bounding boxes by representing the transformed sphere as a quadric surface.
Continue reading Exact Bounding Boxes for Spheres/Ellipsoids
A Beautiful Ray/Mesh Intersection Algorithm
In my last post, I talked about a beautiful method for computing ray/triangle intersections. In this post, I will extend it to computing intersections with triangle fans. Since meshes are often stored in a corner table, which is simply an array of triangle fans, this gives an efficient algorithm for ray tracing triangle meshes.
Continue reading A Beautiful Ray/Mesh Intersection Algorithm
A Beautiful Ray/Triangle Intersection Method
3D ray/triangle intersections are obviously an important part of much of computer graphics. The Möller–Trumbore algorithm, for example, computes these intersections very quickly. But there is another method that I believe is more elegant, and in some cases allows you to compute the intersection for “free.”
Continue reading A Beautiful Ray/Triangle Intersection Method
k-d Forests
Recently I saw an interesting Code Golf problem: create an image using all possible RGB colours. The top ranked submission, by József Fejes, contained some truly beautiful images, but they took an immense amount of time to generate.
Specifying Types
C specifies types like this:
int integer; int array[2]; int *pointer; int function(int); |
The clever rule C follows is that declarations and expressions look the same. So int *pointer can be read as, "from now on, *pointer is an int." Similarly, function(0) is an int, and array[0] is an int. Continue reading Specifying Types