y-it's site

Plotter Art

2026-07-18T00:00:00+00:00

The pictures made here were all made several years ago by now, but I am rewriting the descriptions now.

The first group of pictures are flow fields. Each point on the picture has a direction assigned to it. This produces shape to a similar manner as tributaries form. A bunch of starting points are picked on a grid, and continuously follow the direction at each point they end up at. The resulting picture can be changed by manipulating the directions. For example, squaring a coordinate makes it always positive, locking the paths only increase that coordinate.

For the first picture the direction is decided purely with perlin noise. There are some zigzag artifacts due to the size of the steps taken.

This next picture has both the x and y directions squared, causing the lines to always move to the bottom left.

By squaring only one coordinate this picture has the lines go to the right.

Raising the x and y coordinates of the direction to a high odd power makes it follow cardinal directions.

This next picture reuses the squaring both coordinates trick, but after a change of basis. This causes the direction to by biased towards flowing in an inwards circle.

Changing between an inwards bias and an outwards bias depending on the distance from the center creates a stable ring around the middle.

Adding noise can make results that look noisy.

The change of basis operation can be based on another noise field to create a picture with a regionally varying bias.

I don't actually remember what made this one happen. I think it was a similar change of basis based on perlin noise thing.

This one is just a squaring both coordinates thing again, but rotated to fit on the page different.

Now for a complete change of pace, my cat. This is based on a picture taken with a camera, and then dithered. Then a dot was created in each spot with a black pixel.

The remaining pictures are all variations on a Barnsley fern, or other tree fractal things.

Deriving the Line of Best Fit

2023-12-31T00:00:00+00:00

We will define the set of points P as follows

$P = {(1, 1), (2, 2), (3, 4), \dots}$

And the line of best fit will be defined as

$y = m x + b$

Finally to express the error of a line just sum the error for each point. The error for a point is the squared difference between the point's $y$ coordinate and the lines estimate for the point's $y$ coordinate, $m x + b$ . The reason for squaring it is to make it always positive. Otherwise a positive error and negative error could cancel out. The reason for squaring instead of using an absolute value is for ease of the derivative. As an expression for each point it is $(y - m x - b)^{2}$ . The total error for the whole line can be written as:

$E (m, b) = \sum_{(x, y) ϵ P} {(y - m x - b)}^{2}$

Going forward I will be leaving the bounds off of the summations, as they will all be the same and only muddle up the notation. The next step after finding the error function is to find the minimum. It would be really convenient if there was one minimum and it was the only critical point on the function. After expanding the function it is evident that its highest coefficient term of both $x$ and $y$ is parabolic.

$\sum (y^{2} + m^{2} x^{2} + b^{2} - 2 y m x - 2 y b - 2 m x b)$

That shows that it will have only one critical point. Next is checking if the critical point is a minimum or if it is a maximum or saddle point. As $b$ goes to positive or negative infinity the error function must go to positive infinity.

Less obviously but with similar logic the same is true for $m$ .

Having shown that the critical point is the point we are looking for, the next step is to find it. We will start by taking the partial derivatives of the error function.

$\frac{\partial E}{\partial m} = \sum (2 m x^{2} - 2 y x + 2 x b)$

$\frac{\partial E}{\partial s} = \sum (2 b - 2 y + 2 m x)$

Now all that remains is to find where both of those equal zero. Starting with $\frac{\partial E}{\partial s}$ first set it to zero, then divide both sides by two. Then distribute the summations and you are left with:

$0 = \sum b - \sum y + \sum m x$

The $m$ can be distributed out of the summation and the $\sum y$ can be moved to the other side.

$\sum y = \sum b + m \sum x$

For the next step remember what bounds on the summations are. The term $\sum b$ means the sum of $b$ added for each point. The term $\sum x$ means the total of all the $x$ coordinates. If we divide both sides by the number of points then $\sum b$ will change to $b$ and $\sum x$ will change to the average $x$ value. Now we have the equation

$\bar{y} = m \bar{x} + b$

showing that line of best fit goes through the average point. The other equation doesn't turn out as neat, but still isn't too bad to solve. Doing very similar steps as to the last equation you can find that

$m \sum x^{2} + b \sum x = \sum x y$

Changing all the summations to averages will not be as nice as last time, but still make it easier to work with.

$m \bar{x^{2}} + b \bar{x} = \bar{x y}$

You can then plug in the other formula tothat and solve for $m$ to get

$m = \frac{\bar{x y} - \bar{x} \bar{y}}{\bar{x^{2}} \bar{x^{2}}}$

The result from that can be used with the $\bar{y} = m \bar{x} + b$ equation to find the line of best fit.

Boat

2023-09-23T00:00:00+00:00

A while ago I thought it would be a good idea to build a boat. I gathered a group of my friends to design and construct this thing. We had our first meeting where we agreed on random garbage we had that could be fashioned into a boat. The buoyancy would be provided from old barrels of car wash chemicals and the surface palettes and from leftover deck supplies. We bought 13 8' 2x3's for the main frame of the boat, and some metal strap to hold the barrels on.

We then looked for the paint that best resembled the blue color of Weezer's debut album "Weezer", which made us appear to be professional boat constructors. We were able to get the boat to pass a NY inspection.

After the incredible success of actually making a "seaworthy" vessel out of garbage we wanted to step it up a bit. We wanted benches to allow more people to fit easier, and we lights so we could continue operating after sunset. If we were putting lights on it we were going to go all out with the electrical system with a horn, navigation lights, deck lights, a radio, and at one point a pump powered water gun.

Interactive boat models

High School Photography

2023-05-21T00:00:00+00:00

These pictures were all taken for my advanced photography class in high school. All of the really fuzzy noisy ones where taken through a camera obscura made from a cardboard box.

Ruins

2022-09-28T00:00:00+00:00

This is a picture of a building in Annapolis mid destruction. The sky was not originally this purple, nor were the shadows this intense.

Four Player Chess

2022-04-22T00:00:00+00:00

I designed and printed a four player chess set, which can be packaged into a relatively small space. The outer 3 by 8 sections that each player's pieces start in can detach, allowing it to be stored in the same size as the inner 8 by 8 section. Removing the outer sections also allows normal two player chess to be played on the board. The chess pieces I printed are hexagon chess pieces I found on thingiverse. All the models that I made I used openscad for.

The list of things that were printed for this are

main 8 by 8 board
two 3 by 8 boards with the colors one way
two 3 by 8 boards with the colors the other way
four sets of chess pieces
eight connecters
box

Getting the chessboards to print with two colors was a fun challenge, especially to get them to print with the least effort on my part. The easiest to set up was to just do two prints, the squares and the back, and to change the filament between the prints. The things that I don't like about this approach are:

Printer will cool down in between the prints
The printer might home with slight differences for the two prints

The way I ended up handling it was to make a new profile in the slicer, which I called ender 3 manual dual filament. In the profile I said that the printer has two extruders, each doing a different color. When it was time to switch the extruder it was using, the command was M600. What that gcode command does is:

Pause the print
Park the print head
Eject the filament
Beep and wait for you to put the new filament in
Purge the filament
Resume the print

Naturally it didn't just work like that, instead it completely ignored that command and started printing the whole thing in one color. It turned out that the stock firmware did not have the M600 command implemented. This meant that I had to find an alternative or put custom firmware on the printer. The first thing I did was to find an alternative. Instead of the M600 I wrote:

Switch to relative moving
Move up
Pause
Move back down
Switch back to absolute moving

The bad news is that after being paused for too long it would disable the steppers and misalign the print. In the end I just put custom firmware on the printer with the ADVANCED_PAUSE_FEATURE and NOZZLE_PARK_FEATURE enabled.

3D Scanning with an xbox Kinect

2022-03-02T00:00:00+00:00

I have always wanted to do some 3d scanning, but I couldn't get photogrammetry set up on my computer. Recently I got a kinect, a camera that also does depth so it should be able to do 3d scanning. Processing seemed like a good choice for a language to use, since I am familiar with it and it has a kinect library. My code is directly descended from the point cloud example for openkinect-for-processing.

The first step after getting the depth values from the kinect is to undo the perspective distortion. A small change in position in points that are close to the kinect have a much larger change in apparent position than points that are far from the kinect. The basic solution to this is to multiply the x and the y by the z.

Page about getting world coordinates from the kinect

Now that there is a point cloud of world coordinates, it just has to be saved to a file. The format I chose is obj, since it is so easy to output from a program. To put a vertex in an obj file, just put a line in the file with v x y z where v is the letter v, and x y z are the x, y, and z coordinates of the vertex. After all this is implemented, the program is capable of 3d scanning.

All you have to do is take multiple scans from different angles, then remove the unwanted points, then match them up (I used blender to do this), and then turn the points into a mesh (I used meshlab to do this). The problem with this approach is that it is a lot of effort, particularly the lining up the point clouds. I found out that meshlab is able to mesh all the point clouds, and them match them up, or I could mesh the scans in the program I wrote. All the points in the point cloud come from the kinect, which captures them as a grid. This allows us to take the grid, and keep the faces how they were, even after transforming them with the depth.

The next thing to automate is removing the unwanted points. I chose to do this by filtering the depth. Anything more than 1.5 meters I filtered out, since it is probably the background. Additionally I filtered out the points with a depth of zero, since that means that their depth did not get recorded correctly. This creates two problems. The easy one is that some faces will no longer have all the vertices, so I just got rid of those faces. The hard one is that when the vertices get deleted, the indices of all the following ones change. What I originally had in the code was to add all the vertices, and then the indices for the faces would follow a simple x + y*width formula. Alteratively, in pseudocode:

for x from 0 to width:
	for y from 0 to height:
		add vertex x, y, z to obj file

for x from 0 to width:
	for y from 0 to height:
		add face x+y*width (x+1)+y*width (x+1)+(y+1)*width x+(y+1)*width to obj file

My solution to recalculating the indices is for the face to store a reference to the vertices, and turn it to a number after the unnecessary vertices get deleted.

Pseudocode:

for x from 0 to width:
	for y from 0 to height:
		append to vertices vertex x, y, z

for x from 0 to width-1:
	for y from 0 to height-1:
		append to faces face(
				vertex a = get vertex x+y*width
				vertex b = get vertex (x+1)+y*width
				vertex c = get vertex (x+1)+(y+1)*width
				vertex d = get vertex x+(y+1)*width
				)

for every vertex
	if the depth is not in range, get rid of it

	index = 0

for every remaining vertex
	add vertex to obj file
	set to index of the vertex to index
	increment index

for every face
	if the face still has all of its vertices
		add face a.index, b.index, c.index, d.index to obj file

Now the output of the code is several obj files that can be opened and aligned with meshlab.

Colorado Springs

2021-08-23T00:00:00+00:00

These are a bunch of pictures I got in Colorado Springs on a trip in 2021. The first bunch are from the Garden of the Gods.

The next picture is from a modern gold mine.

This picture is from the remains of an older gold mine.

All of these pictures where taken on a Motorola droid RAZR smartphone camera.

Parametric Twist Containers

2021-08-12T00:00:00+00:00

I printed one of the twist containers that Devin Montes made, and it turned out great. I had to make some of my own, so I could have any number of sides that I wanted. The idea is that there are two twisted prisms, where on is just slightly bigger than the other. If you get the tolerance right they will just barely slide past one another, which makes it hard for the air to get out. I designed them using the program openscad.

Since there is an inside and an outside the model should be saved as two stl files. I accomplished this with a shell script and an if statement with the input from the command. Here is the shell script.

#!/bin/sh
openscad -DPART='"inside"' -o inside.stl twist.scad
openscad -DPART='"outside"' -o outside.stl twist.scad

And then for openscad there needs to be an if statement to use this input. If the part is equal to "inside" then render the inside. Otherwise, if it equals "outside", render the outside. And if it is neither of those, display both for preview purposes. Here is the important part of the openscad code:

if (PART == "inside") {
    inside();
} else if (PART == "outside") {
    outside();
} else {
    inside();
    translate([size*2,0,0]) outside();
}

If the arguments say inside, it renders the inside. If they say outside, it renders the outside. Otherwise, it will preview both. Here is the full openscad code:

$fn=256; //resolution of shape, turn higher for more tris
height=150; //The height of the container
tolerance=.75; //The distance between the outer and the inner vases
size=70; //Approximately the diameter of the container
roundness=20; //The radius of the corners
twist=-360; //Amount it twists by, negative to get a right handed container
chamfer_thickness=.5; //How tal the chamfer is
chamfer_width=.5; //How far in the chamfer goes
sides=2; //Number of sides on the container
base_thickness=3; //How tall the grip on the base is
base_width=2; //How far out the grip on the base is
base_slope=base_width/base_thickness; //How steep the grip is

module base() { //Make a circle for every side, and evenly space them
    hull() {
        for (i=[1:sides])
            rotate(360/sides*i)translate([size/2-roundness,0,0])circle(roundness);
        }
}

module handle() { //Make two tapered prisms, and put them together
    translate([0,0,-base_thickness])
    linear_extrude(base_thickness/2,scale=(size+base_slope*base_thickness)/size)base();
    scale([1,1,-1])
    linear_extrude(base_thickness/2,scale=(size+base_slope*base_thickness)/size)base();

}

module chamfer() { //Make a tapered prism for the top chamfer
    translate([0,0,height-chamfer_thickness])
    linear_extrude(chamfer_thickness,scale=(size-chamfer_width)/size)
    base();
}

//The inside is the combination of a twisted prim, the base, and the chamfer
module inside() {
    union() {
        handle();
            linear_extrude(height-chamfer_thickness,slices=$fn,twist=twist)base();
            chamfer();
    }
}

//The outside is just a twisted prism, just slightly bigger than the inside
module outside() {
    linear_extrude(height,slices=$fn,twist=twist)offset(tolerance)base();
}

//Get part information from the command line, so that both the inside and the outside can be rendered automatically
PART=undef;

if (PART=="inside") {
    inside();
}
if (PART=="outside") {
    outside();
}