So in this work, we're presenting a CAD system
for shaping and patterning of knitted garments.
And you've already seen that machine a few times now.
And here we're going inside of the machine again.
And eventually what is being knitted here is a glove.
And we are going to see it pop out.
There it is.
And it's mostly ready to be worn.
We have a few other samples.
And all of them, I have them with me.
And I'm wearing some of them too,
because it's a little bit cold here.
Come afterwards if you want to see them.
So industrial knitting, the big thing
is that we can create whole garments from scratch.
And that's possible thanks to the control of each
of the individual needles.
But why knitting?
Well, many garments are needed, and with the machines
we have, very little requirement for post-processing.
And furthermore, we have control of the geometry
as well as the patterns, which means
that there is a really big opportunity for user
customization.
But there is a problem, which is that unfortunately,
those machines are very hard to program.
And the interfaces are typically closed.
So we want to fix that and make the machines more accessible.
We envision knitting as a service for government
customization, but this is not yet possible,
so we're trying to push for accessibility and scalability.
I'll go for a very short brief machine knitting background,
since most of you have already seen in the first session what
was happening.
We are working with a V-bed machine.
And schematically, it has two beds
of needles that are facing each other.
The yarn is going to go in between.
And each of the needles can catch the yarn
and do lots of fancy operations with them.
The stitches are loops of yarn which
we can control individually.
And together, they form corsets as well as veils.
The corsets are the rows.
And the veils are the columns.
If you want to increase the width of a corset then
you can do a stitch increase.
And you can do the opposite, which is a stitch decrease
to bring back--
merge some of the stitches.
Now let's look at the current workflows
for programming those machines.
The first workflows basically involved
doing low-level knit programming.
The user is basically specifying all the individual stitches.
This is great, like, full control.
But of course, its--
first, it's non-parametric.
So if you want to do customization,
that's a little bit complicated.
It requires to be an expert.
We have one expert here in the front row.
And there are very few others.
And it's not accessible.
And then recently, we've seen a few techniques that
try to develop the knitting structures on top
of three meshes that enables you to have really crazy shapes,
but they all have in common that they require a 3D model.
And 3D modeling is by itself already
a bottleneck in the design pipeline.
And furthermore, those representation
on not parametric, because they're not going from CAD.
They're actually going from 3D models.
And technically, it's also some sort of over specification.
And finally, there are other workflows
that work with templates.
And those ones have a simpler design space.
They technically would allow mass customization, which
is what we want to go for.
But currently, those approaches either do not
provide parametrization or customization capabilities,
or they're closed and lack composition.
So let's go look at how we do it.
The user can start from a base primitive.
Here this is a tubular sheet.
They can directly manipulate the shape properties
such as the length, the width.
And then they can use some context menu
to adjust some of the parameters.
Here we're going to extend this shape with a joint primitive.
That one is going to model the heel of a sock.
We expose some higher level properties to automatically
adjust low-level parameters.
Given the desired shape, the user
can then edit the patterns.
The first option is to write short programs that
apply operations on group of stitches such as here
with a one-by-one rib.
The pattern might be in conflict with the shape.
And in those scenarios, the interface will tell you, hey,
there is a problem.
Here is an option for how you want to fix it.
The other option is that maybe you
don't want to actually program stuff
because you don't actually know much about programming
and you don't want to have to care.
So instead, we allow you to draw directly on the stitches,
similarly to image editing.
In those cases, we provide you some feedback in terms of the--
error, unfortunate.
Come back.
We open it again.
[INAUDIBLE]
OK, so another option--
I will go a little bit faster since I'm losing time--
is that instead of creating your whole shape from scratch,
you use a template that we have available.
And then you can just adjust the parameters.
You can do simulation to see what we are actually
going to get at the end.
And if you're an expert--
but that's for very few people-- then you
can look at the actual code that is generated.
Now in terms of shaping parameters,
they are not crazy new.
They're basically what already exist.
They are sheets and tubes that are using stitch increases
and decreases.
Here we are looking at the simple flat sheet.
That's the tubular version of the flat sheet.
And then if you want to change the width
along the actual length, then we can do fancier things.
Here we're increasing the actual width.
We're increasing even more.
Or you have a section that is mostly fixed.
And then it increases very fast.
You do it at the bottom, at the top.
You can create many fancy tubular shapes.
We have a joint primitive that basically
models the short rows.
That's what you want to do for knitting your socks.
And then we have a topological primitive that
allows topological branching.
There are some details on the paper
on what type of branchings we support.
But basically, we can do both tubular and flat branches.
Now in terms of patterning, the way
we are dealing with the pattern is
by having a small GSL of instructions that we can apply
on each of those stitches.
And those are the operations and low-level look
at what's happening when you apply all of those operations.
So a knit, that's the wave structure.
Purl is going to be down on the backbed.
And it looks very different.
Tuck is a very subtle one.
Typically here, you might not be able to actually see
what's happening.
But the stitches on the left are slightly larger.
You can create fancier more subtle joining operations.
Miss is basically doing absolutely nothing
with the needle, but that has a pretty big impact
on the final result, because you're
leaving a thread floating.
And then moves are going to move the stitches left and right
to create lace, as we've seen before.
And cross are the cables that we've heard
in the first section about.
What we propose is to allow the user to program--
create some small programs that will select
regions of the actual shape.
And then you can apply different types of patterns on top of it.
If you don't want to program-- and I fully understand why you
would not want to--
then you can instead just draw directly on the shape.
And if you draw a pattern, then there
is the big question of what happens
if you change the shape.
So we provide different types of mechanism for doing that.
By default, you can just assume that the pattern
is going to stay there.
We will potentially just recenter it.
We have a scalable mode that is going
to show very soon, in which case we actually scale the pattern.
That's here.
And there is a tileable mode that
eventually allows you to tile that pattern everywhere
on the surface.
Now in terms of results, because that's
what people are interested in, the first question was,
are our primitives, are they sufficient
for general knitted garments?
Here, those are the first samples from the beginning.
And the beginning of the answer, because the answer
spans a few slides here, is that we can reasonably easily create
gloves as well as basic version of most small-size garments.
And furthermore, we can provide customization on top of those.
But there are a few challenges.
So the first challenge is about the restriction
that we are imposing on the design space.
We are working with very simple shape interactions, which
means that if you have more complex garments, specifically
sweaters, it's going to be very hard to model with our system.
The second challenge-- and that's
also a multi-step challenge-- is scalability.
We want to eventually knit our full garments,
not the small versions that we've seen before.
And adult-size garments are made of very large number
of stitches, so we have to be able to deal with that.
Now in terms of the results for the patterns,
we can mix very complex interactions
of different structures.
In this scarf here, you're looking
at a lace pattern that is styled everywhere on the scarf.
And then you have a wavy red and green in the diagram
pattern that is created by filtering noise
as we predict it.
By mixing the layer types, our patterns
can adapt to the size changes.
But I'll be honest, we are not actually
dealing with what happens at the boundaries.
Everyone talks about the boundaries.
We don't do anything.
And the main reason here is that, as a user,
there are many potential options when
you deal with the boundaries.
Which one is the good option, we don't know yet.
I think there are many interesting areas of, oh,
how do I present those options to the user.
We are not doing anything with it yet.
But of course, we could use some of the algorithms
from Hoffman to actually solve some of those issues.
Another is something a little bit more subtle here,
which is that we are assuming that there
is a very simple shape and pattern separation.
This is completely wrong in practice.
Here we are looking at a glove whose shape
is exactly the same for each of the samples on that screen.
And they look very different.
What's happening here is you start with the glove
without any pattern.
We are going to introduce half-gauge knitting
for the cuff.
Then we actually do our ribs.
That's going to shrink the pattern.
And then eventually we put this on top of it.
And it changes the shape even more,
which means that here the take away is really
we need the physical feedback.
It's very important for the pattern design.
From the user scalability perspective,
there is another issue, which is that if you are dealing
with a full sweater, specifying every stitch
is not going to be something that you want to do.
So we need to have better ways to create those patterns.
Now we wanted to see, our actual casual users
able to use our system?
That would be a great thing.
So we asked external users who had no knitting experience
to create some samples for us.
Now there is a very simple disclaimer,
which is that we have two of those users.
That's not efficient.
It's not a large scale study.
But they gave us some pretty good feedback.
This is one sample that we showed them
for trying to do lace.
And this is what the first user was able to do by himself.
This is another variation using some type
of purls that were hand drawn and other types of pattern
that we imported from our library.
And then we ask them to transfer that onto shapes.
And they successfully did that.
And then we decided to say, OK, let's
ask you to do the full shape from scratch.
You have two options.
You can create it from scratch in the interface.
Or you can use a template.
And the answer from everyone was, we will use the template.
This suggests that currently, simple customization using
our templates is going to likely work,
but full garment design from scratch may not.
And here we're looking at the actual top of the hat.
They modified some of that.
And as a small discussion here, the user one
was very into his pattern design.
He spent a considerable amount of time
trying to recreate the lace that he had in the first samples
onto the beanie.
And they actually developed their own process
for doing that, which consists of creating
the pattern on the micro tile.
The reason here is that, if you have a very small shape,
it's very easy to get very fast feedback.
So they do that at a much smaller scale.
And then they export that to transfer it
to the final shape, which means you want to have something
parametric, because you want to be able to do
that transfer very easily.
And then he also went for an extra glove,
but there is this interesting takeaway here
that it is mostly the end of the talk, which
is that making that green glove on the left
was not as easy as, oh, I have my pattern.
I know that pattern is great.
And here it is.
It's manufactured.
It didn't happen like that.
It actually took a few iterations
to get to the final design.
And what's interesting here is that,
from the virtual perspective, everything seems to be fine.
We have something that actually looks
very fine for the compiler.
The compiler is very happy, no issue.
But at the end of the day, you also
have to tune the parameters of the machine.
And those have some feedbacks that
can be provided from the user perspective,
but they're very hard to tune.
So if you don't do the tuning correctly,
you don't get your manufacturing to work.
So challenge number three-- and I
think that's the actually hardest challenge
to go to full mass customization--
is to be able to do the manufacturability fully modeled
to know what's going to happen.
Currently all the works that have
been trying to do with computer knitting,
they model topological correctness.
And that's not sufficient.
You want to do something more than that.
Machine parameters are critical.
If you don't have the correct tuning, nothing works.
And the biggest problem I've had to deal with
is when something fails, you have no idea why.
And what's happening here behind the hood
is that, if it's something obvious,
then you have an idea why, but you actually don't care,
because you already knew what it was.
If it is something that is related
to the tension, typically what's going to happen
is the tension is distributed semi-randomly
over the structure.
So when it fails, like, you can't reproduce the failure.
It's going to fail somewhere else on the next try.
We need some tools to get feedback
from the machine that tells us, hey, here there
is something odd that happened.
And the current machines don't provide you computer vision
on top of the machine.
So that needs to happen eventually.
So takeaways, we have full parametric design
tool, pattern design, customization
for non-expert users.
And the changes that are remaining in front of us,
how to do with complex shape interactions--
we have some ideas about that if you want to talk about it.
We have also computational scalability, user scalability,
and modeling the full manufacturability.
If you're interested in this work,
there is a demo and a project online.
You can just go look at them.
And if you're very interested by anything, come talk to me.
That's it.
[APPLAUSE]
Thanks, excellent presentation.
Let's take one question from the audience.
OK, could you talk a little bit about--
I think the focus here has largely been
on novice users or beginners.
Have you had feedback from expert users or ideas
on whether this is appropriate for expert use?
Does it remove some level of control
that would be needed for experts?
Or could it be a great tool for them as well.
Good question.
So there are two very broad different types
of users in the spectrum.
Here you have the actual casual users.
So from an accessibility perspective, of course
we want to be able to target them.
It's not going to happen very soon, because there are so
many different roadblocks that have to be crossed.
But of course, the people in the industry,
they also want to be able to shorten their own pipeline.
And that's for a very simple reason,
which is that the current pipeline is horrendous.
Like, I've talked with a few companies.
It takes too much time, because there are too many people
in the actual pipeline.
And there is a lot of disconnection
between each of the steps.
So if they can shorten that, then they can reduce the price.
And then you have even better designs out there.
So they are the first ones who are
going to be able to benefit from the work
that we're trying to do.
They're not going to benefit from that one I think,
because from what I've talked about,
there are too many limitations that we want to tackle.
But eventually, it's going to come.
I think there are lots of companies
that are interested in changing the current workflows.
All right, let's think Alex again for the presentation.
[APPLAUSE]