Testing Waters

Searchâ€¦

Projects

Patterns

Geometry

Lists

Wilson Garden

Bengaluru Streets for People Challenge (February 2021)

The objective is to create a parametric tool that computationally applies design intent to any neighborhood and generates multiple design iterations driven by relevant input parameters such as the existing layout and parking space requirements.

The tool groups existing blocks into clusters referred to as Pedestrian Blocks that are bound by one-way streets for vehicular movement and parking. Every generated iteration provides information about the area of the Pedestrian Blocks and the number of Parking Spaces for that particular iteration.

In addition to the Pedestrian Blocks, mentioned earlier the design proposal introduces the concept of an Asteroid which is a super elliptical shaped garden located at every vehicular intersection and enforces one directional traffic flow across the neighborhood. The introduction of multiple such gardens across the neighborhood should do some justice to the name the neighborhood carries.

01

02

03

04

05

06

07

08

09

10

â€‹

â€‹

â€‹

â€‹

â€‹

â€‹

The one directional flow is to ensure continuous movement of traffic without any crisscrossing or directional conflict at any intersection. Traffic effectively moves in circles around Pedestrian blocks and the shortest vehicular route between any two Pedestrian Blocks within the neighborhood is a zigzag. However it continues to be direct and straight for cyclists and pedestrians who can cut across Pedestrian Blocks. This maze of one-ways should also serve to discourage through traffic.

11

12

13

14

15

16

17

18

19

20

â€‹

â€‹

â€‹

â€‹

â€‹

â€‹

â€‹

â€‹

â€‹

The computational iterations are based on hard coded design intent and should necessarily be reviewed by the community to refine and correct any obvious faults and shortcomings that a purely parametrically driven design approach could throw up. However the advantage of such an approach is that discussions with the concerned community would not be based on a particular design being imposed on them, but with a tool that enables them to evaluate and refine multiple options within the framework of a broad design concept.

Design Script

Functions

Functions

1

/*

2

Road Width for One Side Parallel Parking : 8m

3

Road Width for Two Side Parallel Parking : 10.0m

4

Stall Intervals 7.0m, Stall Width: 2.0m, Aisle Width 2.5m, Lane Width 3.5m

5

â€‹

6

Road Width for One Side 30 degree Parking : 12m

7

Stall Intervals 5.5m, Stall Width 5.0m,Aisle Width 3.5m, Lane Width 3.5m

8

*/

9

â€‹

10

//Control Variables

11

//Max Block Area

12

mxa01 = (Math.PI*Math.Pow(400000,2)/1000000)/23;

13

//Lane Width

14

lnW01 = 2800;

15

//Turning Radius

16

tnR01 = 7000;

17

//Parallel Parking

18

pkW01 = 2400;

19

pkL01 = 7000;

20

â€‹

21

//Deserialize blocks as Surfaces

22

blk01 = List.Flatten(Geometry.DeserializeFromSAB(DSOffice.Data.ImportCSV("G:\\My Drive\\Bengaluru-Competition\\Shantinagar\\Design\\20210208.csv",false)),-1);

23

blk02 = Blks04((Blks03(List.ShiftIndices(blk01,1),mxa01)),mxa01);

24

â€‹

25

//Perimeter Curves

26

prm01 = PolyCurve.ByJoinedCurves(PolySurface.ByJoinedSurfaces(blk01).PerimeterCurves());

27

prm02 = PolyCurve.ByJoinedCurves(blk02.PerimeterCurves());

28

prm03 = prm02.Offset(-lnW01);

29

prm04 = prm03.Fillet(tnR01,false).Fillet(tnR01,true);

30

prm05 = prm04.Offset(-pkW01);

31

â€‹

32

//Number of Car Parking spaces including periphery

33

crP01 = Math.Sum(List.Flatten(Math.Floor(List.RemoveIfNot(prm05.Explode()<1>,"Line").Length/pkL01),-1));

34

â€‹

35

//Number of Car Parking spaces excluding main roads

36

crP02 = crP01 - Math.Floor((prm01.Length/2)/pkL01);

37

â€‹

38

//Graphics

39

ctl01 = PolySurface.ByJoinedSurfaces(List.Flatten(blk01.PerimeterCurves().Extrude(Vector.ZAxis()),-1));

40

â€‹

41

prk01 = Surface.ByLoft(List.Transpose([prm04,prm05]));

42

blk03 = prm05.Patch();

43

int01 = ctl01.Intersect(blk03);

44

â€‹

45

//Color

46

clr01 = GeometryColor.ByGeometryColor(prk01,Color.ByARGB(255,0,0,255));

47

clr02 = GeometryColor.ByGeometryColor(blk03,Color.ByARGB(255,255,255,0));

48

clr03 = GeometryColor.ByGeometryColor(int01,Color.ByARGB(50,255,0,0));

49

â€‹

50

[clr01,clr02,clr03];

Copied!

â€‹

1

def Blks01(blks:var[]..[],mxar)

2

{

3

//Adjacent blocks with a common junction and total area less than max

4

blk00 = List.SortByKey(blks,blks[0].DistanceTo(blks))["sortedList"];

5

return [Imperative]

6

{

7

ind01 = 0;

8

ind02 = 0;

9

are01 = 0;

10

blk01 = [];

11

blk02 = [];

12

for (i in blk00)

13

{

14

if(i.DistanceTo(blk00[0])==0 && are01 < mxar)

15

{

16

blk01[ind01] = i;

17

ind01 = ind01 + 1;

18

are01 = i.Area/1000000 + are01;

19

}

20

else

21

{

22

blk02[ind02] = i;

23

ind02 = ind02 + 1;

24

}

25

}

26

return List.Flatten([PolySurface.ByJoinedSurfaces(blk01),blk02],-1);

27

}

28

};

29

â€‹

30

def Blks02 (blks:var[]..[],mxar)

31

{

32

//Additional blocks if adjacent junction blocks area less than max

33

blk1 = [Imperative]

34

{

35

blk00 = Blks01(blks,mxar);

36

are01 = blk00[0].Area/1000000;

37

blk01 = [];

38

bln01 = List.Count(blks) != List.Count(blk00);

39

while (are01 < mxar && bln01)

40

{

41

are01 = blk01[0].Area/1000000;

42

blk01 = Blks01(blk00,mxar);

43

for (i in List.RestOfItems(blk01))

44

{

45

bln00 = (i.DistanceTo(blk01[0])==0) || false;

46

}

47

bln01 = bln00 && List.Count(RestOfItems(blk01))>0;

48

blk00 = blk01;

49

}

50

//return blk01;

51

return blk00;

52

}

53

â€‹

54

blk2 = List.Count(blk1)>0?List.SortByKey(blk1,blk1[0].DistanceTo(blk1))["sortedList"]:blk1;

55

return blk2;

56

};

Copied!

1

def Blks03 (blks:var[]..[],mxar)

2

{

3

//Block groupings

4

return [Imperative]

5

{

6

bln01 = true;

7

blk03 = [];

8

ind01 = 0;

9

itr01 = 0;

10

while (bln01)

11

{

12

bln02 = List.Count(Blks01(blks,mxar))==List.Count(blks);

13

blk01 = Blks02(blks,mxar);

14

blk02 = List.RestOfItems(blk01);

15

blk03[ind01] = List.FirstItem(blk01);

16

bln01 = List.Count(blk02)>0;

17

ind01 = ind01 + 1;

18

blks = blk02;

19

}

20

return List.Flatten([blk03,blks],-1);

21

}

22

};

23

â€‹

24

def Blks04 (blks:var[]..[],mxar)

25

{

26

//Merging small isolated blocks

27

blks1 = blks;

28

blk00 = blks1.Explode();

29

cnt01 = List.Count(blk00<1>);

30

are01 = Math.Sum(blk00.Area/1000000);

31

bln01 = are01<mxar/4;

32

â€‹

33

blk01 = List.FilterByBoolMask(blks1,bln01);

34

blk02 = blk01["out"];

35

blk03 = blk01["in"];

36

dis01 = blk03<1>.DistanceTo(blk02<2>)==0;

37

ind01 = List.IndexOf(dis01<1>,true);

38

ind02 = 0;

39

blk04 = [Imperative]

40

{

41

for (i in ind01)

42

{

43

rep01 = List.Flatten([blk02[i],blk03[ind02]],-1);

44

blk02 = List.ReplaceItemAtIndex(blk02,i,rep01);

45

â€‹

46

ind02 = ind02 + 1;

47

}

48

return blk02;

49

}

50

Copied!

â€‹

wilsonGarden.zip

40KB

Binary

Dynamo ver 2.10

Bengaluru-Competition-brief.pdf

5MB

PDF

BS4P_SiteB_BEN1808_01 .pdf

10MB

PDF

BS4P_SiteB_BEN1808_02.pdf

3MB

PDF

BS4P_SiteB_BEN1808_03.pdf

34KB

PDF

â€‹

Last modified 10mo ago

Copy link