0:04

So this work is titled, Apparent Layer

Â Operations for the Manipulation of Deformable Objects.

Â The problem we discussed discussed here is

Â that interaction with deformable objects is very difficult.

Â 0:19

And by deformed object we may hear, this kind of

Â interrelated stacked closed and also lobs, and so on.

Â Now typical approach is to round, continuously, physical assimilation.

Â And then user moves one vortex and then rely on physics.

Â This is always physically possibly.

Â But this is kind of a little bit inflexible.

Â You know, you can not penetrate pass an object and so on.

Â So it's always needs to be physically bodied.

Â And this can be inflexible in some situations for modeling purposes.

Â And besides a possibility, it's the directory

Â control all the vertices one by one.

Â In this way you can do what ever you want.

Â However, it can be very, very, tedious, right?

Â And you have too many, many control of vertices.

Â So what we introduce here is one example of semantic-level operations.

Â By semantics like, layers and so on.

Â So if you look at the physical

Â configuration, here's some want to do sum operations.

Â But these some operations in some meaning for operation for

Â the user; like changes order or layers of this comment.

Â However, from computer to, point of view,

Â this is just a collection of vortex coordinates.

Â So many, many, numerical values.

Â So additionally we're asked to control these numerical valued directory.

Â But here we tried to allow the user to work on this 3D model with semantic-level.

Â 1:52

Now specifically we want to, we introduce here is layer a operations

Â for 3D modeling, and I think you know the three layer operations.

Â So in 2D drawing systems you can always have a layer ordering.

Â So you can say, go to front or go to back and so.

Â For example in PowerPoint you can say you can say

Â go to back and then you will get this result.

Â And then, go to front and then you will get this result.

Â So we want to get this kind of operation for the comments,

Â for the cloth to go front, or front to back and so on.

Â So

Â 2:30

so we specifically we introduced two new techniques here.

Â One is layer swap.

Â So you just click here and then the system changes the layer ordering.

Â And then the other is, you drag one piece, and then

Â you can go up, and down, depending on the user control.

Â So let me show you a demonstration.

Â 2:50

So you have a three dimensional cloth placed on the floor, like this one.

Â And then, you can deform it just by pulling, and pushing, and so on.

Â And here this is just a standard physics based dragging.

Â So it's always physically bodied.

Â However, for example, if you want to try to change the layer

Â ordering of this part and this part, it can be, it suddenly becomes very tedious.

Â You have to move it away.

Â And then move it here, and it comes back.

Â But this takes a lot of steps and then global configuration changes.

Â And so if you want to swap this blue and this green, now it's almost impossible.

Â But here what we propose is just a single click operation to do it.

Â So if you want to swap this layer just,

Â just, click here and the system will automatically swaps.

Â So it's very subtle but internally the system do a lot of things.

Â And if you click here, just swap, and there you will get this instantly.

Â And this operation can be very, very tedious, if

Â you use standard rigging operation or robotics space control.

Â Let me show you a couple more examples.

Â So here's an example, so you have green, purple and blue here.

Â And for example if you

Â try to swap green and purple blue

Â 4:19

if you click here user want the system to swap green and blue.

Â But if you, the system do it naively, then there

Â can be a penetration or intersection between part one blue.

Â So system automatically analyze it the same

Â and then try to abort invalid configurations.

Â So if you click here instead of putting blue somewhere the

Â system decided to bring the green to the front to abort intersection.

Â 4:50

again, the same thing, so if you click blue,

Â if you want to swap blue and purple, if

Â you just do it, if the purple is on

Â top of green, there'll be a intersection here, right?

Â So in, in order to prevent an intersection, or penetration when the user

Â clicks here, the system should push the purple one all the way to the bottom.

Â And that's what we do here.

Â If you click here, the system automatically

Â pushes the purple one all the way back.

Â 5:25

And here is a folded pocket handkerchief.

Â If you click here you still do, you know, outward penetration and the

Â system will automatically decide to move the top layer all the way to the bottom.

Â Then you will get this shape.

Â 5:44

And if you click here the direction of a spiral completely swaps.

Â And also if you have this one for example you can do something like

Â this very quickly, just by a successive breaking, and then you will get the same.

Â So this way of changing the way of making a

Â knot can be very difficult due to our traditional approaches.

Â And

Â 6:22

And the same operation can be applicable for a knot or ropes.

Â So if you click here you can swap the layers

Â and you can quickly change the configuration of a knot.

Â And then here the same thing you can change the whole direction of a

Â twist or you can change the configuration of a net, like this one.

Â [BLANK_AUDIO]

Â Okay, so that's how layer's work.

Â And next operation I will show is layer hardware dragging.

Â So, in standard dragging, you know, it's a

Â dragged object always on top of existing one.

Â However, if you press shift key down, during

Â dragging it will automatically goes below the colliding clothing.

Â 7:08

So by combining shift up and shift down, you go up and then go down and so on.

Â So this is very useful for making a knot here, so you go up without shift

Â and shift down, and then shift up, and then shift down, and shift up.

Â So in this way, you can generate a

Â three dimensional knot just by two dimensional dragging.

Â Okay.

Â 7:45

So layer swap.

Â So, this is a before the layer swap and then the after the layer swap.

Â Suppose I use a click somewhere here.

Â I use to try to swap yellow with blue.

Â And in order to do the system will actually do a lot of same inside the box.

Â So first, the system project, 3D configuration onto the screen space.

Â And then analyze the configuration, and then,

Â 8:10

generate a structure for the list graph.

Â List graph is, each subregion represents a layered

Â structure and then system maintains adjacency graph of the, regions.

Â And then, depending, starting from this current configuration.

Â Depending on the user input, system swaps layers, in this 2.5D representation.

Â The layer is a list graph representation.

Â And then after that, system takes this two dimensional

Â input configuration, and then automatically synthesize it, a 3D shape.

Â And then offer a physical acquisition to get the final, solid shape.

Â So that's what we do.

Â The first step is the project, projection, and analysis.

Â 8:56

So projection is from 3D, to 2D vector representation

Â and the similar technique was presented by Eisemann is 2009.

Â And then after getting to the two-dimensional vector,

Â 2.5D representation, we construct a list graph presentation.

Â And this technique was inspired by a local layering technique proposed in 2009 here.

Â 9:31

Okay, so given this list graph you know,

Â 2.5D layer structure, the system updates the list graph.

Â So this, this is before configuration and then gets a new configuration.

Â So what it actually do is to change the ordering of this local layers.

Â However, the important thing is to, to avoid invalid configurations.

Â So here's an example of invalid configuration.

Â So type one, invalid configuration is like this one.

Â So you see the two sub-regions here and here.

Â 10:07

And then in the top region about this region here, blue is

Â on top of purple, and here purple is on top of blue.

Â So if this kind of configuration happens then there

Â will be an intersection of penetration here which means

Â undefinable, so this is type 1 error or type

Â one invalid configuration, so another invalid configuration is like this.

Â So this is not so obvious but suppose this is folded, you know, this is dark blue

Â and the light blue is folded and connected, and

Â then, and then it's connected layer should be adjacent.

Â Otherwise, you know, there will be a penetration, so that's a problem.

Â 10:50

So what we do is to consider all possible permutations of layer orders

Â in each region and then tries to find valid configuration.

Â And to do this we actually do kind of

Â an exhaustive search of all the combinations in this space.

Â 11:21

And this is two step operation.

Â So first operation is to get geometric

Â reconstruction, so there is no gravity, there's no

Â physics, just reconstruct three-dimensional

Â layered structure, just tied

Â up to the computer depths from 2D layer.

Â And then after that, we apply physics you

Â know, apply gravity to get the final deducted shape.

Â 11:45

So, in summary, we introduced the layer operations for cloth and ropes.

Â And them specifically we need to do today

Â a swap single group and change layer ordering and

Â then change the layer dragging, you can go above and then go down using a shift key.

Â Then the algorithm for what we do

Â is projection 2.5D representation called the list graph.

Â So project the order and synthesize go back to 3D.

Â To learn more, the original paper was

Â published as Apparent Layer Operations for the

Â Manipulation of Deformable Objects, and 2D layer

Â operations was introduced as Local Layering in 2009.

Â So our work is inspired by this work.

Â And also if you want to more about 3D to 2D projection, I recommend you

Â take a look at this Visibility algorithm for

Â converting 3D meshes into editable 2d vector graphics.

Â So this one enables to combine from 3D graphics to 2D vector installations.

Â Thank you.

Â