[MUSIC PLAYING]
ADRIANA SCHULZ: Thanks for being here.
And welcome to the Computational Fabrication Colloquium.
We're very excited to have a wide range of topics
that we're going to be talking about today
from HCI to networks to programming languages.
So we will start with Liang.
You can come up.
Liang is a second year PhD student.
He is working with Jon.
He works in HCI, specifically on fabrication techniques
and tangible user interfaces.
LIANG HE: Thank you.
Thank you for the intro.
All right, so today, my topic is Modeling and Fabricating
Interactivity and Creativity with Object Properties.
So I think that 3D printing has been widely used these days.
And we can see 3D printing has been used for rapidly making
things like the mechanical components--
also creating some powerful devices like the prosthetics,
and also design some new fashion.
But there is a one problem in these 3D printed objects.
They are usually very static.
And in the commercial market, some companies already
produced some softer printing materials
like the soft PLA, NinjaFlex, or Tango.
But usually, people doesn't have a lot of control
over these materials in the 3D printing process.
And in the HCI research, particularly, researchers
has already explored a lot of different approaches
to create deformable and interactive objects
like this one.
He's using a silicon compound and sand casting techniques
to create some deformable parts in the 3D printed objects
and make the application interactive.
Or customize some printer how to print a soft teddy bear toy
for your kid or for yourself.
AUDIENCE: [LAUGHTER]
LIANG HE: The process is really like the traditional 3D
printing process, like, layer by layer--
layerized manufacturing.
But the resulting print is very, very durable.
Yeah.
And also, researchers are using metamaterials,
which is a kind of microstructure
with many mechanical properties.
In these 3D printed objects, this micro mater
can be used for certain functionalities.
Finally, with the rigid filaments,
we also can create some movable creatures using
some mechanical construction.
AUDIENCE: [LAUGHTER]
LIANG HE: Yeah, these materials are very rigid, not soft.
So my big research question is how
to support end users to design, model,
and fabricate interactive and creative objects?
And in my research approach, I focus on two parts.
The first one is the computational design tool.
And the second one is a custom fabricating machine.
And I also investigate object properties,
like the material or mechanical properties,
and try to integrate them into these two parts.
So today, I'm going to show two ongoing research projects.
And the first one is called Ondule,
which is about 3D printing and designing deformable objects
with spring-loaded structures--
I will highlight a computational design tool in this project.
And the second one is called FuzzPrint,
which is about 3D printing fluffy objects using cotton.
And in that project, I created a new machine.
So for the first project, my big question is,
how can we enable designers to rapidly
design, build, and fabricate deformable 3D-printable
objects?
And our solution is a set of novel techniques
to add elastic deformation behaviors to static 3D models
using a combination of a spring and a joint.
And we're using spring because spring are wider
used in mechanical engineering and haven't
been investigated in HCI area.
And they can exert a lot of expressive behaviors
and also store a lot of potential energy.
So first of all, I wanted to introduce the design space.
We are particularly looking into two parts.
The first one is a spring.
And based on this spring theory from the engineering,
we can allow the user to control two parameters.
Because when we convert those objects to the object spring,
we usually can get the size of a spring for under geometry.
And also, we assume the material is consistent throughout the 3D
printing.
So the two parameters the user can control-- one
is a ten gap, which is the gap distance between two
coils and the wire diameter.
And we also introduced the joints.
We provide five types.
For example, the prismatic joint,
which is a rail and a slider.
So using that joint inside a spring,
the part can only compress or stretch.
And also, like, the other one is knuckle joint.
It's basically a chain of cenergy rod and socket.
And you can constrain the object to deform in one direction.
And we also combined individual behaviors like stretch,
twist, or bending together-- compound behavior.
For example, the gray area part shows two compound behaviors.
The cylindrical joint used for twists and stretch
and compress.
The ball joint is used for all direction bending.
OK, I'm going to show you one quick workflow
of designing a cylinder.
So for example, we have this model, which is a cylinder.
And the first one, we will generate a spring, which
is taking over the deformation.
And the user can parametrize in the spring.
And now we will generate the essential constraint
using a specific joint.
And in this case, the cylinder can only compress or stretch.
It cannot twist and bend.
And finally, we generated the outer close
of the cylinder, which you will approximate at the outer
geometry of the shape.
And if you see from the top view,
you can see all the structures are nesting inside the model.
And to enable the user to create such design,
we created a plugin on Rhino.
And in the plugin, the user can select part of the model
and convert that part into a spring.
And also, the user can control the spring parameters
and the joint parameters to customize the design.
I'm going to show a quick video demo.
So for example, you want to convert
the two arms of the robot into flexible structure.
First of all, select the first arm,
and convert it to a spring.
See, here, the yellow part is the essential spring,
which is responsible for the deformation.
The user can parametrize the spring design
on the right side-- the panel here.
Like, the user can change the stiffness of a spring,
and also precisely can show the wide diameter and the ten gap,
as I said before.
And also, the user can add different constraint joint.
And the good thing of this design
is that you can integrate a lot of different parts
into one design.
For example, we already finished one arm.
And then we can move on to another arm
and change the design.
Here I'm going to show another design, which
is about making the other arm only bendable in one direction.
And then you will see how the user
can decide a bending direction using our tool.
So right now, it generates a chain of knuckle joints.
And the user can change the bending angle.
So for this project, I would create a bunch of applications.
First of all, it is a snake body,
so we incorporated all the design in one snake body.
And the tail doesn't have any constraints.
So it can be free--
deformed.
The second one is a rain doll.
We wanted to showcase the approximation
of the outer close spring.
This other one is a practical tool
for the people with muscle weakness.
So with this tool's rail springs,
the user can press the machine easily and cut things
in their daily life.
All right, so beside those applications,
we also created a bunch of other applications like
the jack-in-the-box-- the car was spring-loaded--
and also some IO device, which is connected to a digital
application.
The second project, our question is,
like, how can we enable children to rapidly design, build,
and fabricate fluffy, safe, and easy to configure objects.
So when we are young, we usually play blocks
and learn how to construct 3D models.
And so I'm thinking maybe we can create another type of toy
for them, and we can create some very safe and user-friendly
objects to render 3D modeling precise.
And we use cotton because cotton is very cheap.
And it's deformable and easy to bound no dangerous--
you know, the material.
And it has a lot of material properties.
It can diffuse the light.
And also it can absorb the water and user
can use different tools to manipulate the cotton.
So for this project, it's at a very early stage.
And we just built machinery here.
So we customize one printer-- a 3D printer.
And then we create a custom printer head
from the left to right.
From the right to left, there's a glue extrusion mechanism
which will drop the glue, which is just super glue.
And in the middle, there's a mechanism called a ball
delivery mechanism.
It will suck one cotton ball from a pack of balls,
and then deliver each ball one by one.
And the right most part is the punch gun.
So obviously, I will show you the whole process.
This is a quick demo of the process.
So first of all, we would drop one glue on the printer bed.
And then drop the cotton ball.
But it's not tightly bounded on the--
then we press it.
AUDIENCE: [LAUGHTER]
LIANG HE: And all the movement is controlled by the machine.
And in the future, we will generate the G code
and do all the routing.
Yeah, this is the idea.
[CHUCKLING]
AUDIENCE: [LAUGHTER]
LIANG HE: Yeah, OK.
So the whole process is like we import the one 3D model,
and we convert it to a Voxelizer model.
And then each of the voxel could be
represented by a cotton ball.
Or , we can change the voxels.
You can combine three or four voxels as a one cotton ball
in the printing process.
And then we would generate that that G code.
And based on the G code, we will do those series of operations,
as you've seen in the few video.
And do we also came up with a glue routing algorithm
to tightly bound each layer of the cotton balls.
And we're introducing the 1.5 feet layer here.
So basically, between four cotton balls--
the cotton balls-- we will drop another ball on this 1.5 layer.
So in that way, the whole object will be very robust
and tightly connected.
And in the future, we want to build some applications
particularly for children, like the cloud-like like lamp, which
will diffuse the light in a bedroom as a nightlight.
Or we can create a soft enclosure for the robotics.
And also, we can add some ink, different colored ink,
into the cotton balls.
Yeah, so I think that that's a big design
space for us to explore.
For further projects, we also wanted to be able to--
computational design tool for the children, so children
can easily manipulate and design the 3D objects in the tool.
And then the system will help them generate the G code
and operate the machine.
And also, we wanted to update the machine-- the print head.
Yeah, and then thank you.
And I wanted to appreciate my advisor, Jon Froehlich.
I'm happy to take questions.
AUDIENCE: [APPLAUSE]
ADRIANA SCHULZ: So maybe we can take one or two questions
while Chandra's setting up.
OK, then maybe I will ask one.
You talked about developing computational design
tools and also customized machines, right?
What do you think is a good way to link these two directions?
LIANG HE: Because have you seen before in my two projects--
I started this project from a specific idea or proposal.
So in that way, I probably will create a very particular design
tool and the machine for the end users.
And I think in the future, I probably
want to create some abstraction in the design tool.
For example, I can extract the user requirements
and design the abstraction modules in the design tool.
And then also on the hardware side,
I also want to create some modules, which
can be reconfigurable for different purpose.
And I think that that's a better way to approach this area.
Yeah.
ADRIANA SCHULZ: Thanks.
Great.
Thank you.
Yeah, I think these are really cool project and really
great questions on also these, as you said abstractions.
This is something that we've been thinking a lot about
and brings us to our next talk, which
is programming languages for manufacturing,
and which is a great way to do these kind of abstractions.
So Chandra's going to tell us about this really cool work
that she just presented at ICFP.
CHANDRA NANDI: Hi, everyone.
My name is Chandra.
And I'm a fourth year registrant in the programming languages
and software engineering lab.
And today, I'm going to talk about Functional Programming
for Computer-Aided Design.
So as you already saw from Liang's talk,
CAD and 3D printing is becoming almost like a revolution now.
And there are so many different applications for 3D
printing these days.
So starting from automobiles to space programs to medicine,
such as customizing prostheses, the applications
are just numerous.
And what's even more exciting is that recently,
due to democratized fabrication, the price
for 3D printers and other similar devices have gone down.
And as a result of that, if you have
a couple of hundred dollars to spare,
you can actually quite easily buy a 3D printer
and start printing various types of things for day-to-day life,
various tool parts, or just devices for aesthetic purposes.
And this is all actually really great.
And as you can see, we have printed
a lot of things in the past couple years in our lab itself.
So what's a problem in this space
is that the software pipeline that is currently
used in fabrication has certain challenges.
And the particular challenge that I'm
going to talk about today is about design tools.
So the first thing you do when you 3D print something
is you design a model.
And for that, you use various types of CAD packages.
And it turns out that these CAD packages are actually
really hard to use, especially if you're a hobbyist
and you've never done this before.
The learning curve is really steep.
A lot of these are actually also very expensive.
And often, there isn't really any proper specification.
So you kind of try out something.
And it doesn't work.
Then you do something else.
And eventually, you get it to work.
So to avoid all of these problems, what people do today
is they just go to these repositories like Thingiverse
and GRABCAD.
And they just download models from these repositories.
And now, this is actually really great
because once you download something,
all you have to do is slice it and print it.
So you don't need to buy any CAD package.
You don't need to understand how to design models and so on.
So this is great as well.
Unfortunately, when you download a model
from these websites, most of the time,
these are in the form of a mesh.
And these meshes are really hard to modify.
So let me tell you a little story that
can demonstrate this better.
So a while ago, I downloaded this model from the internet.
So this is a hex wrench holder.
So if you go to Ikea and you buy a set of hex wrenches,
then you can put them in this holder just to store them.
So I put my wrenches in.
And I was not very happy because my wrenches were not sitting
parallel to one another.
And it was really important for me that there were parallel.
So--
AUDIENCE: [LAUGHTER]
CHANDRA NANDI: --I went and got a mesh editing tool.
And I started to modify the mesh.
And it turned out that just a simple modification, which
was just rotating a hole a little bit,
was actually really tedious.
I was constantly breaking the mesh.
And then I just gave up.
And I was just sitting there and wishing that, you know,
I wish I had a higher level program that
was a little bit more abstract so that I could look at it
and understand what's going on and maybe make this change much
easier.
So what do we actually want here?
We want some tool that can take any mesh
and convert it to a CAD program that
is equivalent to that mesh.
So that is exactly what I'm going to talk about today.
So we have built this tool called
Reincarnate that takes a mesh and gives you back a CAD
program.
And if you compile that CAD program,
you're going to get back that same mesh.
So if you give this mesh that I showed you before to our tool,
what it's going to do is it's going
to produce a program in a language that we built.
And it looks like that.
And once you have that program, in this case,
a modification was literally one line.
So we added a line.
And that line was a notation about z-axis.
And once we did that, we printed it again.
And I was really happy because everything was parallel.
And it was great.
So now that we have seen that this is a useful tool,
let's try and understand how we build this.
So in order to build this tool, we had this key insight
that the fabrication pipeline can be viewed as a compiler.
So why is that the case?
Well, because everything we do in this fabrication
world is actually right--
programs in certain languages-- compile them
to different types of representations.
And ultimately, we generate a G code,
which you can think of as assembly for 3D printers.
And that is what the 3D printer actually interprets.
And it moves the extruder and prints your thing for you.
So this can be viewed as a compiler.
So if it is a compiler, then what
are the languages that are the sources and the targets?
So the language that we care about is the topmost language.
This is the CAD language.
So here is an example of a language that we built.
If you're familiar with languages such as OpenSCAD,
then this might look similar, you know.
So this language can support various primitives,
such as cubes and polyhedrons.
It can support various affine transformations,
such as rotation and scaling and translation.
And it can also do various binary operations,
such as union and difference and intersection.
So this is our source language.
So we are going to write programs in this language.
And it will be compiled down to a mesh.
So mesh is a data structure which
is a list of faces that represent
the surface of your model.
So it's not a solid representation.
It's a surface representation.
And you can think of a mesh as an intermediate representation,
which is actually really great if you
want to do any kind of geometry computations.
And it turns out that these are the formats that are most
popularly used in online repositories like Thingiverse
and so on.
So these are really useful.
So now we have seen a CAD language.
And we have seen a mesh.
And I told you that we can view this fabrication pipeline
as a compiler.
So let's just write the compiler.
So the compiler is a function, in this case,
that takes a CAD program and gives you back a mesh.
So let's see what it does for a cube.
So it's going to produce the mesh for a cube.
And if you render it, you can see that it's a cube.
So it's a cube.
The bottom most left corner is at the origin.
And the dimensions are all one.
So now what happens when we want to do something more complex?
So for example, if you have a affine transformed CAD--
so it's very similar to what you can
expect from any other language.
So it's going to recursively compile the child
and apply the affine transformation
to the vertices of that child.
And similarly, if you have a union
or a different intersection, you're
going to compile that children and then apply the operation
to the meshes of the children.
So let's actually run this compiler on this simple example
and see what happens.
And we will actually run this using small steps,
so at every step, we are going to focus on a part
and compile it down, and then move on from there.
So here is a program in the language that I described.
So this is a union of a cube and another cube
that is translated by amount 2 along the x-axis.
So what the compiler is going to do
is it will focus on the first child, which is a cube.
And it will crunch it down to a mesh.
And we already saw how that happens.
Now, after that, it is going to focus on the next child, which
is the right child.
And then it'll crunch that down to a mesh that
corresponds to it.
Now, once it has compiled everything down to the meshes,
finally, it will apply this union to the meshes.
And that will give us the final mesh for this model.
But this is actually not what we wanted.
We want the backward process.
So the solution that we actually care about
for not having to learn any CAD, and this magically download
models and decompile them to CAD programs
is actually to go in the backward direction.
So starting from a mesh, we want to go back to a CAD program.
And the way we are going to do that is by using a technique
called synthesis.
And essentially, in this case, what that boils down to
is just flipping the arrows of the compiler.
Now, you might be wondering how is that happening?
Well, because you have already done all the hard work.
We have built a compiler.
And we have used these small steps
to make the compiler make progress.
And because we have done all of that,
now we can magically get a synthesis tool
by just flipping the arrows of the compiler.
Now, of course, nothing comes for free.
There are still some challenges that we need to address.
And in particular, there are three things.
So the first thing is when you go in the forward direction,
you lose a lot of information.
So when you want to go backwards,
you need to find a way to get that information back.
If you look at that blue lozenge on the slide,
the kind of information that we are losing here
is just by looking at that shape,
you can't actually tell how it was actually designed.
In this case, it was designed by intersecting two cylinders.
But it might have been a primitive in the language.
So we don't actually know how it was manufactured
or how it was designed.
So how did we get back this information?
So it turns out that there is a technique called
evaluation context.
I'm not going to talk about the details of this.
But it's a technique in programming languages
that can actually let you use a geometric context
to replace certain parts of the mesh
by some primitives that are provided in the language.
So we can use that to retrieve the information that was
lost in the forward process.
The second problem is that there are
a lot of geometry challenges that we need to solve in order
to go backwards.
So how do we do that?
So we implemented various oracles
that can guide the synthesis process.
It turns out that there are so many different CAD
programs that when you compile, you see the same mesh back.
So we needed to be able to make this entire process much more
tractable than it actually is.
And these geometric oracles help us do this.
And the third problem is that the entire backward process
is actually quite nondeterministic.
Because at every step, there are so many different directions
in which you can go, and you don't want
to go in all those directions.
You need to be able to follow certain directions that
can lead you to a proper CAD program that is actually
what you want.
So the way we do that is by using search.
So we have actually built this tool.
So we have built a compiler.
And we have also built this decompiler.
And we have used it on about 20 to 25 models
that we downloaded from Thingiverse.
And so Thingiverse happens to be one
of the most popular repositories for sharing designs for 3D
printing.
And we were able to synthesize CAD programs up
to 200 lines of code.
So basically, that brings me to the end of this talk.
So the takeaways from my talk are that functional programming
is great.
And you can use it in this really exciting domain
of fabrication.
And in particular, the things that you can do with it is you
can design domain specific languages.
You can provide semantics to them.
You can build compilers.
And you can even prove correctness for your compilers.
And after doing all of those exciting things,
you can even do more cool things like build fancy decompilers
and program synthesis tools that can let you go back
from meshes to CAD programs.
And with that, I would like to thank my collaborators
in the project.
And if you are interested, I would recommend
you to go and look at our tool.
And if you have any questions, I'm happy to take them.
Thank you.
AUDIENCE: [APPLAUSE]
ADRIANA SCHULZ: So questions?
Start set
AUDIENCE: This is really cool.
How did you come up with the set of shapes
that were going to be in your geometric oracles?
CHANDRA NANDI: The shapes in the language
or you mean in the oracle.
AUDIENCE: Ah.
I don't know which I mean.
CHANDRA NANDI: Oh.
I mean, so right now, the language
supports shapes that are very cube-like.
So you can have prisms and cubes and cubites.
And for more fancy things like spheres,
we have hard-coded models--
like, primitives for them.
But it would be cool and we would
like to extend it to support, like, real curves and so on.
So all the oracles that we have are actually
using those printers which I just mentioned-- so cubes
and cubites, and prisms.
ADRIANA SCHULZ: Next up is Vikram,
who is a PhD student in networks and mobile systems lab.
And he's going to be telling us about his work
that he just presented at UIST on wireless analytics for 3D
printed objects.
VIKRAM IYER: All right, hi, everyone.
So today, I'm going to be talking
about Wireless Analytics for 3D Printed Objects.
And this is joint work with Justin in our group,
as well as another undergrad Ian,
and advised by Jen and Shyam.
And so before I go any further, what do we mean by analytics--
wireless analytics?
Our goal in this project is to track
the use of functional 3D printed objects over time.
So for example, if we have things like this Phoenix hand--
it's a prosthetic hand--
these types of things have a pretty high rate
of abandonment.
But what if we could track when a user is actually
opening and closing this hand or even how
much they open and close it?
Tracking these kinds of things could give us
important information about their use
to address these issues of abandonment.
And we could also think of other everyday objects
like this plastic pill bottle here.
If we could track things like when a user actually
unscrews the cap, we could make sure
that someone has either taken their medication
or, say, make sure they haven't taken too much.
So really, our goal overall is to embed wireless sensing
into these 3D printed objects.
We can also think beyond everyday objects,
like to things like this robotic arm here.
If we could use a printed object to--
or track the motion of a printed object
and map that to this robot arm, there
are all kinds of other cool things that we could do.
Now, at this point, I've shown you some applications
of what we could do if we could track
the use of printed objects.
Well, and the most obvious way to do
that would be to embed electronic sensors in them.
The problem is that this requires first designers
to have a pretty strong understanding
of the electronics and circuits on top
of being experts in the mechanical design as well.
And second, any electronic component
requires some kind of power source.
So that means then you'd have to deal with batteries
or have an RFID reader pretty close by.
So in this work, we take a different approach,
and instead, we co-design our 3D printed objects and sensors
to create completely plastic objects that can communicate,
but without any electronics.
We call this work printed analytics,
which is a wireless and circuitless platform that
can capture, store, and transmit information about the use of 3D
printed objects.
And then I'm going to explain how
this works in the context of a couple of motivating
applications--
first, printed prosthetics, then smart pill bottles,
and a wireless insulin pen.
So to give you an overview, I'm going
to start by explaining how we can 3D print objects that
can communicate wirelessly.
Then I'll go on to talk about how
we can decode the wireless signals
and how we can use that to track motion.
And last, I'll talk about how we can actually store information
in these objects to enable analytics outside
of our wireless range.
So first, I'm going to talk about how we actually
print these objects.
And to really understand this, first
we need to answer the question, how can
a plastic object communicate?
The answer is that unlike things like our Wi-Fi chips
that exist in our phones and everything else,
our printed objects communicate using reflections.
And this requires three different components.
The first is an antenna, second a switch, and then
the message that we want to transmit.
The way this works is we have an incoming radio signal
that hits this antenna.
And then when we toggle or switch on and off,
that changes how that antenna absorbs or reflects a signal.
And so by controlling that switch,
we can produce a changing reflection over time and use
that to communicate information.
So next, I'm going to go into a little bit more detail
and walk you through how we build each of these components.
So first off, how do we 3D print an antenna?
The first step in our design process
is to start with a well-known reference
design for an antenna.
But the problem is that we can't just
copy a design for a metal antenna
because the performance of an antenna
depends a lot on things like the material properties.
And in our case, we're going to be
using a conductive 3D printer filament
to actually fabricate them.
So our next step is to take this original design
and then model it in an electromagnetic simulator
to optimize parameters like the length and the width
to get the frequency and bandwidth that we want.
And then last, we actually fabricate
this using, like I said, a conductive 3D printer filament
on a dual material printer.
And we get something like this antenna you see here.
That's something that we actually
use in our printed objects.
So next, how do we build a switch?
Now, remember that for things like a pill bottle
like I'm showing in this video, that switch
has to be able to move in two directions.
So the main components of our switch
are we have a spring and a conductive contact.
So on the left here, we have our cantilever spring,
which can actually move both up or down because
of its symmetric design.
And what happens is we have this gear.
Basically, as it's turning clockwise,
it's going to push that spring in one direction.
When it turns counterclockwise, it'll push it in the other.
On the reverse side, we have our antennas and the switch
contacts.
So again, as that gear is turning,
it's going to push those contacts to either touch
the antenna at the top or touch the antenna at the bottom.
And that's going to create the changing reflection.
So here's an example of our switch
in action integrated into the Phoenix hand
that I showed you before.
And we can see that the switches either
are moving up or down to touch the antenna
at the top or the bottom.
And this creates this pattern of changing reflections
that we see at the bottom.
That's what we get at our receiver.
So next, now that I've shown you how we actually
print these things, let's go on to understand
how we can decode these signals that we get from them.
So the first step is we record the raw signal
on a software defined radio.
And the problem is we can see in this raw signal
those little peaks that I showed you before.
But we also have lots of noise from the environment.
So the next step is we go through,
and we apply some filters, and count the number of peaks
that we have in this signal, which corresponds to our data.
In the interest of time, I'm going
to skip through some of the details
about how we extend the range of our transmitter.
But to give you an overview, our system
works up to about four meters from our access point.
So next, if we look at how we can actually
track rotational motion once we've decoded our signals,
here's another video showing the Phoenix hand again.
And what we see here is as we turn that gear,
we get six peaks this time.
And what we can do is we can map that number of peaks
to the number of times or basically
the amount that that gear is turned
and the number of times it's pressed a switch.
And we can see that across a whole range
of 180 degrees of motion, we can figure out
how much this thing has moved.
The other question is, of course, how
do we figure out the direction that the gear is turning?
It could be going counterclockwise or clockwise.
And the way that we do this is by using this asymmetric gear
design where we have this pattern of six teeth followed
by four followed by three.
And if we look at this pattern of peaks
that we get on our receiver, by simply looking
at that sequence and the order that it appears in,
we can figure out whether our gear is turning
clockwise or counterclockwise.
So last, I'd like to talk a little bit
about how we can enable analytics
outside our wireless range.
And I'm going to motivate this by talking about an application
like an insulin pen.
Now, what we want to do here is we
want to store the number of times this has been pressed.
And we want to accumulate the number of button presses
to know how much insulin has been dispensed.
And last, of course, once we have that data stored,
we want to upload it once we're back in our wireless range.
The key idea here is that we're going to store information
in the rotation of a spring.
So the way this works is when you apply force or press down
the button on the insulin pen, it's
going to coil up this spring.
The question, of course, is how do
we do that in a controlled way.
And we do that by using a ratchet mechanism
to coil up this spring in a controlled fashion.
So the way this works is a ratchet
is a mechanism that can only turn freely in one direction.
So if you look at the pattern of teeth
that we have here in these grooves, when the ratchet turns
in one direction, it can move freely.
But in the other, it's going to come back and get stuck.
So what we can do with this ratchet is
when it's turning in one direction,
we accumulate all of our rotation
and store up energy in that spring.
And then when we press a button, we'll release that.
And we get our data back.
And here's a brief video showing how that works.
Again, we're pressing it down, coiling up the ratchet,
and in just a second, I'm going to press a button
to release that.
And we get our backscatter data.
So some quick thoughts on how we can
improve on this in the future.
We're currently working on reducing the form
factor of this to make it fit into smaller objects,
storing additional information about printed objects,
and hopefully, increasing the wireless range
from across a room to, say, across a whole home.
So to conclude, I've shown you how printed objects can
communicate and how we can store information about them
and how we can enable analytics for applications
like printed prosthetics, pill bottles, and a wireless insulin
pen.
Thank you.
AUDIENCE: [APPLAUSE]
AUDIENCE: When you're doing the analysis on the intended
design, is that a consol or something?
VIKRAM IYER: Yeah, it was actually HFSS.
AUDIENCE: OK.
VIKRAM IYER: Yeah.
AUDIENCE: Yeah.
So there, can you take into account the structure of 3D
printed conductive material?
VIKRAM IYER: Yeah, so that's actually
a great question that's not something
I've found a way to model very well, as far as,
like, the different layers that we have
and how those will impact the structure of the printed
object.
But I've definitely seen that what you get when you actually
model it in standard electromagnetic simulators
isn't quite the performance that you get on the actual printed
object.
AUDIENCE: A great research problem.
VIKRAM IYER: Yeah, definitely.
[CHUCKLING] Anyone else?
AUDIENCE: Yeah.
Yeah, so it seems like in particular
with zombie applications that you talk about,
you can imagine really serious security and privacy
concerns with the data that you're sort of collecting.
So if you have the transmitter and the receiver,
are there strong guarantees that only the receiver can actually
receive that data?
VIKRAM IYER: Yeah, so one thing right now is, of course,
our wireless range is limited.
The other thing that we've been looking at
is how we can encode or, like, basically have
some kind of encoding on the gear to encrypt
what information we're sending.
So then you'd have to know that information
to be able to decode the signal.
ADRIANA SCHULZ: And next is Megan.
She is co-advised by Jen and Scott Hudson, at CMU.
She's spending the year with us here at UW.
And she's going to tell us about some cool work on knitting.
MEGAN HOFMANN: This is research done in collaboration
with the Carnegie Mellon University Textiles
Lab, along with my collaborators Lea Albaugh, Ticha Sethapakdi,
Jessica Hodgins, Jennifer Mankoff, and Jim McCann.
And I want to start off by saying this is not
a project about 3D printing.
And we did not invent a knitting machine.
In fact, almost everyone in this room
is probably wearing something that
was made with an industrial knitting machine.
If you're wearing a sweater because it's cold outside--
industrial knitting machine.
If you're wearing socks--
industrial knitting machine.
If you're wearing a orthopedic brace--
industrial knitting machine.
If you're-- actually, I don't think this furniture is
knitted.
But most furniture that has any stretch to it--
knitting.
And there's lots of other interesting applications
of industrial knitting in the future.
You can create 3D shapes with knitting,
which means that if you dip those 3D shapes into cement,
you can make really lightweight bridges
or other architectural structures.
And at the CMU Textiles Lab, we're
really interested in thinking about how can we
make industrial knitting machines more
accessible from a computer-aided design perspective.
So the first place we started with this in 2016
when we were the Disney Research Pittsburgh Textiles Lab
was to build a compiler for the low level machine
instructions that run these machines so that we can create
different knitted primitives relatively easy,
like this teddy bear outfit.
And then this year at SIGRAPH, we
started to think a little bit more about complex shapes.
And so we can do something like take
a 3D mesh of, say, your favorite Stanford bunny
and generate knitting instructions.
But the next step we're starting to look at
is thinking about texture.
So this is my co-author Lea Albaugh's work.
She presented this work at a fashion show.
And she was thinking about different ways
of controlling textures and the interesting properties
of textures.
So you can make a really ruffly skirt
or you can make this interesting shoulder pad structure.
But the problem is is that creating 3D knitted structures
is really difficult. So what we've started with
is a very simple pipeline that starts
with a parser of a hand knitting language.
We did not invent this language.
It actually exists.
It wasn't designed for computers.
It was designed for people.
And we compile this down to something
that we call a knit graph, which is just
a basic representation of the functional properties
of a knitted structure.
And we can apply a lot of interesting algorithms-- pretty
standard classic graph algorithms--
to manipulate these structures in interesting ways
and combine them together.
And then we throw this in to KnitOut,
which is the term for most of the prior work I
was showing earlier.
And we get knitted results.
And we have based off of our sample
from a online repository of knitting samples,
we have 400 plus swatches of knitted textures.
So if anyone wants to see one of these things live,
come down after the talk.
But for the brevity and shortness on time,
I'm going to stick to just these kind of first three components.
And I'm going to start with the KnitSpeak Parser.
So the state-of-the-art for industrial knitting is this
terrible, terrible image editing tool.
So if you want to think about knitting as a bunch of stitches
kind of all structured in rows and columns like a picture,
you might start to think, well, let's just name every stitch
a color.
And let's have someone label every single pixel
as the stitch they want at that space.
But if you're repeating a structure over a large series
of space-- maybe 10,000 stitches-- a million stitches--
that's about the number that would go into a sweater--
this can be really tedious.
And so fashion designers don't do this.
Engineers at knitting machine companies do this.
But there are lots of people who know about knitting.
And they are not engineers.
And in fact, they have invented their own ways
of describing knitted structures so that they can render
these things in on their own.
And their instructions look oddly
like a programming language.
So they give you different commands
for all of the instructions in a specific set.
They may repeat these commands over time
and say, like, do this particular row
on row 1, 3, and 5.
And then they have charting tools
that can help them represent these visually so
that they know what they're making as they're knitting it.
And so we did a really simple thing.
We just took this language.
We built a parser for it.
It rendered pretty accurately across the sample
that we looked at.
And now we can generate these swatches
of different interesting knitted textures.
And this reveals some interesting things
about knitted textures.
They have lots of fun properties.
That can stretch and scrunch in.
They can have a pastae change, where they look like a lace
where you have lots of holes through it.
And they can even change the shape
entirely of a rectangular fabric and make it tilt onto its side.
So how do we represent-- what are we outputting
from this KnitSpeak Parser?
Well, to explain that, I'm going to have
to explain how knitting works and specifically
this idea of a loop-to-loop constraint.
So if anyone's ever held a string
and wrapped it into a loop, you know
that if you pull on two ends of that string,
the loop's going to fall apart.
But if you pull a loop through that loop,
the loop that you originally made--
the green loop at the bottom--
is going to be stable.
And you can pull it through in either direction.
And now you have two different sides of a knitted structure.
So if you're wearing anything knitted,
I encourage you to flip it over and notice
that it looks completely different on the opposite side.
This is the notion of the two simplest stitches you
can make-- a knit and a purl.
But we can combine loops.
So we can decrease the number of loops in a row
by pulling them through on one stitch.
Or we can increase the number of loops
by adding what we call a yarn over, which
is just a loop with no parents.
And then we can do even weirder things,
like we can start to cross these loops over one another.
And this ends up making a stiffer structure and also kind
of embosses the fabric so that it
looks like there's a stitch that's traveling in a diagonal.
And if we make a basic grid of these different loops that
are stabilized by one another, we have a knitted structure.
And a knitted structure is a linked list
of loops called a yarn.
AUDIENCE: [LAUGHTER]
MEGAN HOFMANN: [CHUCKLING] Or it's
a series of loops that are connected to one another
in what we call a knit graph.
So a knit graph is where each node is a loop.
And the directed graph between them
is how the loop is pulled through another loop
with this loop-to-loop constraint
that all loops must have a child or else they will unravel.
So let's think about a particular problem
with these nested structures.
These textures are great, except that their output
in tiles that usually have a resolution of somewhere
between a centimeter and a half a foot, so that's
a really poor resolution.
But because of this loop-to-loop constraint,
there's lots of dependencies across these tiles.
And so if we want to remove any of these stitches,
we have to do so carefully.
So in this case, in this texture,
which is about four inches on either side,
you have four tiles.
You have a resolution of one inch.
But removing things from images or something that looks
like an image as nothing new.
Back in 2007, Avidan and Shamir invented seam carving,
which is just a dynamic programming
technique for removing a seam--
not to be confused with the seams in this paper--
of pixels that are the least relevant in an image.
And so we want to apply the same approach
to these tiles of texture.
And when we think about the value of a single stitch,
we're going to think about first the functional constraints.
How many loops depend on this particular loop?
That's a bug.
Oh, well, we'll skip forward to the algorithm.
So what we're going to do is we're
going to assign these values.
And you might already start to see a path of 1, 1, 1 in red
and think that kind of looks like the chevron that was
represented by this texture.
And then as we sum up the value of all of the smallest
dependencies, we get this path that
follows that those black dots.
And we can remove those black dots
from the image or the knitted structure.
And now we have a slightly reduced texture,
which means that we can make smaller and smaller tiles.
And our resolution is back down to a stitch.
And what I want you to take away from this idea
is that machine knitting is a unique fabrication
tool that has been relatively unexplored in the literature.
It can produce complex shapes with fabric without sewing.
And the knitted texture are more interesting
because they have these functional
and aesthetic properties.
They're stiff.
We can control the drape.
They stretch in different interesting angles and ways.
And finally, we can express them as a simple node-link graph,
which means we can apply all of these classic computer science
algorithms to solve and to manipulate them
in interesting ways.
Are there any questions?
AUDIENCE: [APPLAUSE]
AUDIENCE: Did you ever have any problems
where things in KnitSpeak didn't map well to the machine
knitted?
MEGAN HOFMANN: So we actually got lucky that there is--
so the charting tool that this--
we'll go back to that one--
that image the chart image comes from
is generated by a place called Stitch Maps, which
has a language already in it.
So we knew that everything would be parsable.
It does end up lining up that they engineered their language
particularly well--
that if you look at the majority of published
books of knitted textures, they use a very similar form
to this.
It's essentially following the same grammar
so that we could have a sample from books
that are out there as well as this entire repository.
We were guaranteed that they would parse because they
wouldn't have been a chart on the website if they didn't.
We had a few exclusions where there are properties
in their language that actually can't be expressed
on a knitting machine because hand knitters have
more control.
If you want to see samples of things
that can't be machine knitted but can be hand knitted,
I've got a sweater with a black berry
stitch that's particularly difficult for the machine.
AUDIENCE: Is there a version of KnitSpeak
for circular knitting machines as well?
MEGAN HOFMANN: Yes.
And the only change is that instead
of saying row, row, row, row, row, you say round,
round, round, round, round.
[CHUCKLING] It's the exact same language.
And the graph can be represented both ways
because we represent the order in which the loops occur
as a linked list.
And so we just say, like, as you move to the next row,
the linked list doesn't have to shift backwards.
AUDIENCE: Yes, so this was a super cool talk.
Thanks.
But one quick question about making or incorporating
different materials into this framework-- so to what extent
does it take into account the differences in, say,
swatches that are produced by running
the same set of instructions over, like, a different sort
of, like, fiber.
MEGAN HOFMANN: So we have only knitted
these in cashmere, which is a relatively expensive activity.
But you can-- [LAUGHTER] knit on an industrial knitting machine
with a variety of fibers.
Shima Seiki, who is the company that
produces our knitting machine sells
a lot of fibers, including conductive fibers, meaning you
could probably make circuits.
We haven't explored it yet.
And we know that it will affect properties
like the stretchiness and the gauge
because those are as correlated to the material
as they are to the overall structure.
One of the things we're looking at in future work
is that if you take these different properties,
is there at least consistency in how they change so that you can
model things in regular yarn, but then predict them
for something like a metal.
ADRIANA SCHULZ: Thanks.
So let's thank again all the speakers.
And there will be a time if you guys have questions
and want to talk more.
AUDIENCE: [APPLAUSE]
[MUSIC PLAYING]
For more infomation >> BMW X5 3.0si High Executive Navigatie, Xenon, leer, camera, 19inch, pdc v+a, trekhaak, keyless - Duration: 1:12. 
For more infomation >> Opel KARL 1.0 ecoFLEX 75pk Edition ** Airco, Bluetooth, Lage KM-Stand ** - Duration: 1:10. 
For more infomation >> Mazda 3 2.0 SkyActiv-G 120 TS+ Navi - Duration: 1:09. 
For more infomation >> 糖尿病桑椹健康 糖尿病人可以吃桑葚吗？为什么？ - Duration: 2:56. 
For more infomation >> SignalBooster.com = Clear Cell Phone Calls + Fast Mobile Internet (Indoors and in Vehicles)
For more infomation >> Hyundai H300 2.5 CRDi Dynamic Airco Navigatie - Duration: 0:52. 
For more infomation >> 【フォーミュラE】J SPORTS全戦放送決定、12月15日開幕戦をライブ中継 - Duration: 3:35. 
For more infomation >> "Gilets jaunes" : les 4 options d'Emmanuel Macron pour sortir de la crise- NT - Duration: 10:52. 
For more infomation >> (CC) YUBIN - Thank U Soooo Much (VOSTFR) - Duration: 3:45. 
For more infomation >> Mercedes-Benz E-Klasse 200 K. Avantgarde Automaat - Duration: 1:13. 
No comments:
Post a Comment