Digital 1.)Walls 1.)Walls 3.) Number 3.) Numberofof of Nodes Nodes 1.) 4.) Length Position of ofBamboo Nodes 4.) Position Nodes 4.) Position 1.) Diameter Length ofofBamboo 2.) ofNodes Bamboo 2.) Bamboo 3.) Diameter Number ofofNodes 1.) Length of Bamboo 3.) of Nodes Nodes 4.) Number Position of 2.) Diameter of Bamboo 4.) Position of Nodes 3.) Number of Nodes 1.)Walls Physical Mixed Reality 3.) Number 3.) Numberofof of Nodes Nodes 1.) 4.) Length Position of ofBamboo Nodes 4.) Nodes 4.) Position 1.) Position Length ofofBamboo 2.) Diameter ofNodes Bamboo 2.) Bamboo 3.) Diameter Number ofofNodes 1.) Length of Bamboo 3.) of Nodes Nodes 4.) Number Position of 2.) Diameter of Bamboo 4.) Position of Nodes 3.) Number of Nodes 4.) Position of Nodes 4.) Position of Nodes 2.)Rows 2.)Rows 2.)Rows 2.)Rows 2.)Rows 2.)Rows Clip Clip Clip Clip c.Bamboo c.Bamboo Data Data Input Input Clip c.Bamboo Data Input 1.) Tubes 2.) Length Numberofof Nodes on Tubes 2.) of Nodes on Tubes 3.) Number Enough Length for Notches 3.)Poles 3.)Poles 3.)Poles 3.)Poles 3.)Poles c.Bamboo Data Input c.Bamboo Data Input 1.) 1.) Length Length of of Tubes Tubes 1.) Length of Tubes 2.) Number Number of of Nodes on on Tubes 2.) 2.) Number of Nodes Nodes on Tubes Tubes 3.) Length for 3.) Enough Enoughof Length for Notches Notches 3.) Enough Length Notches 1.) Length Tubesfor Phase 1 Phase Phase Phase Phase 1Phase 1 111 Clip 3.) Enough Length for Notches 1.) Length of Tubes private void CheckNextNode(int index, List NodePt, List pairs, List UseNode) public struct NumberPair { { private void CheckNextNode(int index, List NodePt, List pairs, List UseNode) public struct NumberPair private void CheckNextNode(int index, List NodePt, List pairs, List UseNode) public struct NumberPair { // Base case: If we have reached the last index, return { private readonly int _left; { if (index >= NodePt.Count - 1 ) { public int Left // Base case: If we have reached the last index, return private readonly int _left; //return; Base case: If we have reached the last index, return private readonly int _left; { if (index >= NodePt.Count - 1 ) public int Left if (index >= NodePt.Count - 1 ) public int Left return; { get { return _left; } return;PolesLength = NodePt[index].DistanceTo(NodePt[index + 1]); {} double get { return _left; } get { return _left; } ifdouble ((pairs[index].Right + pairs[index + 1].Left <= PolesLength) && (PolesLength < 2000) && (pairs[index + 1].Right <= PolesLength = NodePt[index].DistanceTo(NodePt[index + 1]); } double PolesLength = NodePt[index].DistanceTo(NodePt[index + 1]); }private readonly int _right; PolesLength)) if ((pairs[index].Right + pairs[index + 1].Left <= PolesLength) && (PolesLength < 2000) && (pairs[index + 1].Right <= if{ ((pairs[index].Right + pairs[index + 1].Left <= PolesLength) && (PolesLength < 2000) && (pairs[index + 1].Right <= public int Right int _right; PolesLength)) private readonly PolesLength)) private readonly int _right; UseNode.Add(NodePt[index]); { { public int Right private void CheckNextNode(int index, pairs, List NodePt, List pairs, List UseNode) public NumberPair { CheckNextNode(index public int Right + 1, NodePt, UseNode); get {struct return _right; } UseNode.Add(NodePt[index]); { } UseNode.Add(NodePt[index]); { {{} + 1, NodePt, UseNode); get { return _right; } //CheckNextNode(index Base case: If we have reached the lastpairs, index, return private readonly int _left; CheckNextNode(index + 1, NodePt, pairs, UseNode); get { return _right; } }else }public int Left (index >=CheckNextNode(int NodePt.Count - 1 ) index, List NodePt, List pairs, List UseNode) }public private void public struct NumberPairleft, int right) {}ifelse NumberPair(int return; { {else { public // If the condition is not met, call the recursive method with the next index {{ NumberPair(int left, int right) get { return _left; {//CheckNextNode(index public NumberPair(int left, int right) Base case: If we have reached the last index, return private readonly int} _left; + 1, NodePt, pairs, UseNode); // If thePolesLength condition is=not met, call the recursive method with the next index { _left = left; NodePt[index].DistanceTo(NodePt[index 1]); index //(index If the >= condition is not met, call method with the+next {}public NodePt.Count - 1NodePt, ) the recursive Left }ifdouble _rightint right; CheckNextNode(index + 1, pairs, UseNode); _left ==left; if ((pairs[index].Right + pairs[index + 1].Left <= PolesLength) && (PolesLength < 2000) && (pairs[index + 1].Right <= + 1, NodePt, pairs, UseNode); = left; return; } } CheckNextNode(index }{ _left _right readonly = right; int _right; PolesLength)) } _right = right; get { return _left; } } }private }{ } double PolesLength = NodePt[index].DistanceTo(NodePt[index + 1]); }public int Right } }{ if UseNode.Add(NodePt[index]); ((pairs[index].Right + pairs[index + 1].Left <= PolesLength) && (PolesLength < 2000) && (pairs[index + 1].Right <= CheckNextNode(index + 1, NodePt, pairs, UseNode); get { return _right; } PolesLength)) private readonly int _right; }{ }public int Right else UseNode.Add(NodePt[index]); { { CheckNextNode(index + 1, NodePt, pairs, UseNode); public get { NumberPair(int return _right; } left, int right) private void CheckNextNode(int index, List NodePt, List pairs, List UseNode){ } // If the condition is not met, call the recursive method with the next index } { pairs, UseNode); CheckNextNode(index + 1, NodePt, _left = left; else // Base case: If we have reached the last index, return }{ _rightNumberPair(int = right; public left, int right) (index >= NodePt.Count - 1 )index } // If the condition is not met, call the ifrecursive }{ method with the next return; } _left = left; CheckNextNode(index + 1, NodePt, pairs, UseNode); } _right = right; double PolesLength = NodePt[index].DistanceTo(NodePt[index + 1]); } } if ((pairs[index].Right + pairs[index + 1].Left <= PolesLength) && (PolesLength < 2000) && (pairs[index + 1].Right } <= PolesLength)) { {3}0 {3}1 {3}2 {3}3 {3}4 {3}5 {3}6 UseNode.Add(NodePt[index]); {3}0 {3}1 {3}2 {3}3 {3}4 {3}5 {3}6 {3}0 {3}1 {3}2 {3}3 {3}4 {3}5 {3}6 CheckNextNode(index + 1, NodePt, pairs, UseNode); } else { // If the condition is not met, call the recursive method with the next index CheckNextNode(index + 1, NodePt, pairs, UseNode); } } 2.) Number of Nodes on Tubes 3.) Enough Length for Notches 3.)Poles {3}7 {3}0 {3}7 {3}7 {3}8 {3}1 {3}8 {3}8 {3}13 {3}7 {3}13 {3}13 {3}14 {3}8 {3}14 {3}14 {3}0 {3}1 {3}7 {3}9 {3}9 {3}3 {3}9 {3}2 {3}2 {3}3 {3}13 {3}14 {3}13 {3}14 {3}13 {4}0 {4}0 {4}0 4.)Tubes {4}3 {4}2 {4}0 {3}12 {3}6 {3}12 {3}12 {3}11 {3}12 {3}11 {3}12 {3}5 {3}10 {3}2 {3}3 Node 1 Node 11 Node private readonly int _right; public int Right { get { return _right; } } public NumberPair(int left, int right) { _left = left; _right = right; } Node 1 Node 2 Node 221 Node } {3}6 {3}4 Node 32 Node Node Node 33 Node 2 {3}5 {4}... {4}... {4}... {3}8 {3}9 {3}11 Node 3 Node 4 Node 44 Node {3}12 Node 2 End Length 550 & 600mm {4}10 550 & 600mm Node 4 {4}... Node 54 Node 55 Node Node Node 333 Node Node 3 Node Node 222 Node 550 & 600mm {4}10 {4}... {4}4 {3}15 {3}15 {3}... {3}15 {3}... {3}... {4}... {4}3 Node 5 Node 65 Node 66 Node {4}2 {3}... {4}4 {3}15 Node 6 {3}... Node 6 {4}3 {4}0 5.)Notches 5.)Notches 5.)Notches Row{4} Row{4} Row{4} {4}0 {4}0 {4}0 {3}... {4}2 {3}... {3}4 {3}... {3}4 {4}1 {3}3 {3}4 {3}3 {3}2 {3}3 {3}2 {3}1 {3}2 {3}1 {3}0 {3}1 {3}0 {3}... {3}0 {3}4 {3}... {3}3 {3}4 {3}2 {3}3 {3}1 {3}0 {4}3{3}2 {4}3 {4}3 {4}2{3}1 {3}0 {4}2 {4}1 Row{4} {4}0 Row{4} {4}0 {4}1 {4}2 Node Node 222 Node Node 3 Node Node 111 Node 2 Node Node 5 Node 1 {3}15 {3}... Node 2 Node 2 Node 7 Node 6 Node 1 Node 1 Node 2 Node 7 Node 8 Node 88 Node Safe Length Safe Safe Length Length Node 1 {3}... {4}3 {3}4 Node 8 {3}3 {4}3 {3}1 {3}2 Node 7 Safe Length Node 8 Safe Length {3}0 Distance Distance >= Distance >= Notching Length >= Notching Length Notching Length Side A Side A A Side 5.)Notches Side B Side B B Side Side A Node 2 Node 2 Node 7 Node 77 Node {4}1 {4}2 {4}1 {4}1 {4}2 Node 3 Node 3 Node 1 Node 1 {3}15 {4}... Node Node 111 Node Node 4 {4}1 {4}0 5.)Notches 5.)Notches End Length 550 & 600mm 550 & & 600mm 600mm 550 {4}10 {4}... {4}4 End Length Node 1 Node 3 {3}10 {4}... {4}... {4}... {4}4{3}14 {4}... {4}4 {4}4 End Length End Length Length End {3}6 {4}10 {4}10 {4}10 {4}3 {4}3 {4}2 {4}3 {4}2 {4}1 {4}2 {4}1 {4}1 {4}1 {3}11 {3}5 {3}11 {3}11 {3}10 {3}9 {3}1 {3}7 4.)Tubes 4.)Tubes {3}4 {3}9 {3}8 {3}0 4.)Tubes 4.)Tubes 4.)Tubes {3}10 {3}4 {3}10 {3}10 public struct NumberPair { private readonly int _left; public int Left { get { return _left; } } {4}1 Row{4} {4}2 {4}3 Side B Side Side B B {4}0 Side A Side B Side B Side A Side A A Side Node 8 Distance >= Notching Length Distance >= Notching Side ALength Safe Length Safe Length Safe Safe Length Length Node-To-Node Length Side A Node-To-Node Length Side B Side B Node-To-Node Length Node-To-Node Node-To-Node Length Length Safe Length Safe Length Distance >= Notching Length Side A Row{3} Row{3} Row{3} Row{3} Row{3} {3}5 {3}5 {3}4 {3}5 {3}3 {3}4 {3}4 {3}3 {3}2B {3}3 Side {3}2 {3}1 {3}2 {3}0 {3}1 {3}1 {3}0 {3}5 {3}0 {3}4 {3}5 {3}3 {3}4 {3}2 {3}3 {3}1 {3}2 {3}0 {3}1 {3}0 Side A Node-To-Node Length Side B Safe Length a.Digital a.Digital Aggregation Aggregation a.Digital Aggregation a.Digital Aggregation b.Bamboo b.Bamboo Selection Selection 1.) 1.) Length Length of of Tubes Tubes 1.) Length of Tubes b.Bamboo Selection b.Bamboo Selection d.Annotation d.Annotation on on Components Components 1.) 1.) Notching Notching Positions Positions 1.) Notching Positions d.Annotation on Components d.Annotation on Components First, we divided the bamboo wall into individual pieces and matched them to the real bamboo poles using a digital interface. By doing this, we measured the bamboo poles separately and used holograms to collect the data. I also applied my coding skills to design a data structure for sorting bamboo materials in a spring studio taught by Leslie Lok. These classes have inspired me to combine design with cutting-edge techniques.