Mudra

https://cycling74.com/project/mudra/

This project is an example of a project made using Max with gen. The author has put together a working synthesizer that boasts the feature of “slice phase synchronization”, which I believe is saying that it can phase shift slices that are put next to each other such that they link up and do not produce discontinuity artifacts in the waveform.

I do not have much experience with Max, so it is hard for empathize with whatever process this person took to create this tool. From an empirical perspective, it looks like the interface is clean enough and that it has lots of useful features. As with all sound generators, I would be very happy if it could include a box for me to type in a mathematical function that I am interested in.

Visual Dictionary

Screenshot of the MIT Visual Dictionary

http://groups.csail.mit.edu/vision/TinyImages/

This project is an attempt to represent words by the distribution of colors among images of them. The project allows users to type in words and train the set by selecting images that match the words and eliminate images that do not match the words. In this way as more and more users help out, the database can objects in scenes with higher and higher accuracy. I like the information visualization components that allow the user to see how the current training is going. It is also nice to see that the colors in the image seem to be indicative of the objects that they are representing, for instance I looked up pegboard and found a mostly brownish image. This project reminds me of one of the ones that we saw in class, which tried to reduce words to a single color. I think this project is much more robust, because it captures a distribution of colors instead of just one. From an information theoretic point of view, these 2 dimensional arrays of color averages can address a larger set of words with higher discrimination. The main thing that I was dissatisfied with was that the images that users need to look at to determine whether they are a good fit or not are too small for me to tell.

I spent a lot of time being afraid of this project.  The large design space is intimidating.  I will describe what I came up with as “solidly ok”

My project combines ofxZxing (a wrapper for a QR code reader) and ofxCurl (a wrapper for CURL) to create a “high-trust platform for exchanging arbitrary information”.  A user holds out a QR code to the program camera, which displays another user’s QR code in exchange.  These QR codes can direct to any kind of digital data, from homepages and maps to to books and films.  Only by trusting the sender and opening the link is the user able to explore its contents.

Interface

The first thing the program’s user sees is themselves, reflected onscreen via a front-facing webcam.  When a user holds a valid QR code in front of the camera, the program recognizes it, takes a snapshot of the user and their code, and replaces it with a snapshot of another user/QR code.  The user can see the other image as long as they are holding their QR code in front of the camera (NOTE: each QR code is linked to a specific response code.  Showing the same QR code multiple times will continue to display the same result).

Exchanging QR codes between users

Snapshots are exchanged across machines by communicating with a server (using CURL).  Users can exchange snapshots and QR codes with users across any number of machines, connecting to people and their data from around the world.

Inspiration

When I saw the QR reader addon, I was inspired by the unique way by which QR codes get used to transfer data: while most digital exchanges base security and “trust” on keeping users anonymous and the data they send well-scrutinized, interfacing with QR codes instead requires a human intermediary, who generally has no idea what the code refers to until they open it.  I imagined exchanging QR codes might flip the traditional data exchange dynamic on its head, in which instead the sender and the world around them would be visible, but the data would be opaque.  Under these circumstances, how do you know whose messages can be trusted?

code is located at https://github.com/amwatson/QR_exchange

Summary: A sinusoidally generated ramen brick.

Instant ramen anticipated the maker movement by nearly forty years, and today it remains the undisputed Arduino of food: cheap, versatile and multicultural. My personal relationship with instant ramen began at a young age. Instant ramen allowed me to connect with my Japanese roots in an area of upstate New York that was devoid of asians.

I used Rhino and Python to generate my ramen brick. I relied on both sine and random functions to ensure that the noodles were structured in a way that was neither precise nor erratic. The most important part of the code is a triply nested for loop that builds the noodles up in layers. If I were to iterate on this project, I’d try to optimize it so that the resulting 3D file is smaller.

Part of the code is based on Robert McNeel’s Flatworm example from the RhinoScript 101 manual.

Ramen Brick
by mlsptn
on Sketchfab

import rhinoscriptsyntax as rs
import random
import math

def noodle():
    crvdomain = rs.CurveDomain(curve_object)
    crosssections = []
    t_step = (crvdomain[1]-crvdomain[0])/samples
    t = crvdomain[0]
    while t<=crvdomain[1]:
        crvcurvature = rs.CurveCurvature(curve_object, t)
        crosssectionplane = None
        if not crvcurvature:
            crvPoint = rs.EvaluateCurve(curve_object, t)
            crvTangent = rs.CurveTangent(curve_object, t)
            crvPerp = (0,0,1)
            crvNormal = rs.VectorCrossProduct(crvTangent, crvPerp)
            crosssectionplane = rs.PlaneFromFrame(crvPoint, crvPerp, crvNormal)
        else:
            crvPoint = crvcurvature[0]
            crvTangent = crvcurvature[1]
            crvPerp = rs.VectorUnitize(crvcurvature[4])
            crvNormal = rs.VectorCrossProduct(crvTangent, crvPerp)
            crosssectionplane = rs.PlaneFromFrame(crvPoint, crvPerp, crvNormal)

        if crosssectionplane:
            csec = rs.AddEllipse(crosssectionplane, bend_radius, perp_radius)
            crosssections.append(csec)
        t += t_step

    if not crosssections: return
    loftsrf = rs.AddLoftSrf(crosssections)
    rs.DeleteObjects(crosssections)

points_list = []
size = 400
depth = 50
num_layers = 7 
strands_per_layer = 50
strand_points = 85
wiggle = 10
layer_spacing = depth / num_layers
strand_spacing = size / strands_per_layer
pt_spacing = size / strand_points
offset_x = 0
offset_z = 0
offset_y = 0
curve_object = None

samples = strand_points
bend_radius = 2.5
perp_radius = 2.5

for layer in xrange(num_layers):
    for strand in xrange(strands_per_layer):
        for pt in xrange(strand_points):
            y = pt * pt_spacing + offset_y
            ang = pt 
            x = offset_x + math.sin(ang)*wiggle
            z = offset_z + random.randint(int(-wiggle/4),int(wiggle/4))
            points_list.append((x,y,z)) 
        offset_x += strand_spacing
        curve_object = rs.AddCurve(points_list) 
        noodle()
        rs.DeleteObject(curve_object)
        points_list = []
    offset_x = random.randint(-wiggle,wiggle)
    offset_z += layer_spacing