A Conceptual Approach to Integrating Computational Methods in Early Stage Design

Wandering some trails, lost in thought, contemplating the possible application of computational approaches to early stage design, I find myself in a jungle. With sunlight filtering through and craving a glimpse of the open sky beyond the foliage, the echo of waves draws me toward rugged cliffs. As I ascend, the foliage thins, the leaves give way to open space, and there it is - the vantage point. I stand on the precipice, toes gripping the edge and …..

…. I find my view obstructed

…. by an imposing built form.

Once my anguish over the insensitivity and incompetence that has resulted in this predicament subsides, I settle down and ponder as to what better choices the designer could have made for both the structure and the view co-exist.

I posit the designer could have ensured that the extents of the built form were curtailed to ensure unobstructed lines of sight to the coast beyond. Essentially a geometric analysis which could be represented and analyzed graphically, I begin to outline a possible computational approach.

1. Creating a Basic Scene: This involves digitally recreating the natural environment where the building will be situated. Peaks, coastlines, vegetation, and other landscape features are modeled to provide a realistic context for the design.

2. Identifying Suitable Locations: Computer-generated geometry is used to analyze the terrain and identify potential building sites that won't obstruct important views or disrupt the natural flow of the landscape.

3. Experimenting with Building Shapes: Architects can then experiment with various building shapes and forms, adjusting them to complement the surrounding environment. This could involve altering the building's footprint, height, orientation, and other parameters to achieve the desired integration with the landscape.

4. Optimizing Fit: Through iterative adjustments and experimentation, the design team can refine the building's placement and form to achieve the best possible fit within the natural surroundings. This iterative process allows for a back-and-forth exploration, ensuring that the final design harmonizes with the landscape while meeting functional and aesthetic requirements.

Objective

Generate a conceptual mass that would take into consideration specific criteria (peak and coast) and define the extents of the intended structure such that they satisfy a specific objective (unobstructed view).

Scene

Let us begin by preparing a conceptual scene that consists of a peak (a cone), a jagged coast-line (a poly-curve) and an initial building mass (a solid) that we will alter.

// Peak
height = 30;
coneStart = Point.ByCoordinates
(0,0,0);
coneEnd = Point.ByCoordinates
	(0,0,height);
peak = GeometryColor.ByGeometryColor
	(Cone.ByPointsRadius
	(coneStart, coneEnd, 25),
	Color.ByARGB(255,55,60,55));


// Coastline
coast = PolyCurve.ByPoints
	(Point.ByCoordinates
		([50,70,90,60,50,30,0,-50],
		[-50,0,25,50,80,60,70,50]));

// Base
base = PolyCurve.ByPoints
	(Point.ByCoordinates
		([50,70,90,60,50,30,0,-50,-50],
		[-50,0,25,50,80,60,70,50,-50]),
		true)
	.ExtrudeAsSolid(0.35);
baseClrd = GeometryColor.ByGeometryColor
	(base,Color.ByARGB(255,200,200,135));

// Water
water = GeometryColor.ByGeometryColor(
	Surface.ByLoft(
		[coast,coast.Offset(300)]),
		Color.ByARGB(50,75,205,235));

// Builing Mass
site = Rectangle.ByCornerPoints
	(Point.ByCoordinates
		([20,20,50,50],
		[50,30,30,50]));
mass = site.ExtrudeAsSolid(20);

// Color Solid
GeometryColor.ByGeometryColor(mass,
Color.ByARGB(255,225,185,145));
GeometryColor.ByGeometryColor(coast.Extrude(0.5).Thicken(0.5),
Color.ByARGB(255,0,0,255));

// Sight Lines
eye = coneEnd;
coastVertices = coast.Points;
sightLines = Line.ByStartPointEndPoint
	(eye, coastVertices);

Vantage

Considering the point at the top of the cone to be the eye level, plot lines from eye level the coast line vertices and loft these lines to create a surface.

Extents

The lofted surface intersects the building mass and splits it in two. The portion above the lofted surface would obstruct views of the coast from the peak and will need to be trimmed. The resulting mass would ensure an unobstructed view from the peak despite its presence.

// Cutting Tool
cuttingTool = Surface.ByRuledLoft
	(sightLines);
GeometryColor.ByGeometryColor(
	cuttingTool, Color.ByARGB(200,190,190,190));

// Trim Solid
trimmedSolid = Solid.Trim
	(mass,
	cuttingTool,
	Point.ByCoordinates(20,50,20));

// Color Solid
GeometryColor.ByGeometryColor(trimmedSolid,
Color.ByARGB(255,225,185,145));

Variation

The trimmed form is faceted as the cutting surface is created with a Ruled Loft

However if the cutting surface was created using a Loft, it would be smooth

Alteration

While retaining the same workflow and code, while only replacing Surface.ByRuledLoft with Surface.ByLoft, an alternate geometry is obtained

// Cutting Tool
cuttingTool = Surface.ByLoft
	(sightLines);
GeometryColor.ByGeometryColor(
	cuttingTool, Color.ByARGB(200,190,190,190));

// Trim Solid
trimmedSolid = Solid.Trim
	(mass,
	cuttingTool,
	Point.ByCoordinates(20,50,20));

// Color Solid
GeometryColor.ByGeometryColor(trimmedSolid,
Color.ByARGB(255,225,185,145));

Iteration

Further design development could involve geometry analysis and creation based on solids, faces, curves, points or normals obtained as a result of prior operations.

We could get the roof as a Surface by Intersecting instead of Slicing and Trimming and then extrude them along their corresponding normals to obtain something that is more than just an extrusion of the original building mass footprint.

// Cutting Tool
cuttingTool = Surface.ByRuledLoft
	(sightLines);
GeometryColor.ByGeometryColor(
	cuttingTool, Color.ByARGB(200,190,190,190));

// Top Surface
massExtents = mass.Intersect(cuttingTool);

// Thicken Surface
massThicken = massExtents.Thicken(-50,false);

// Trim Solid
trimmedSolid = Solid.Trim
	(Solid.ByUnion(massThicken),
	Plane.XY(),
	Point.ByCoordinates(20,50,-20));

// Color Solid
GeometryColor.ByGeometryColor(trimmedSolid,
Color.ByARGB(255,225,185,145));

cuttingTool = Surface.ByLoft
	(sightLines);
GeometryColor.ByGeometryColor(
	cuttingTool, Color.ByARGB(200,190,190,190));
massIntersect = mass.Intersect(cuttingTool)[0];
perimeterCrvs = massIntersect.PerimeterCurves();
perimeterPnts = Curve.PointAtParameter
	(perimeterCrvs<1>,(0..0.3..#10));
perimeterNrmls = Surface.NormalAtPoint
	(massIntersect,perimeterPnts)
	.Reverse();
projectedPnts = Point.Project
	(perimeterPnts, Plane.XY(), perimeterNrmls);
projectedLins = Line.ByStartPointEndPoint
	(perimeterPnts,
	List.Flatten(projectedPnts<1>,-1));
projectedSrfc = Surface.ByLoft(projectedLins);

polySrfc = PolySurface.ByJoinedSurfaces(
List.Flatten([massIntersect,projectedSrfc],-1));

GeometryColor.ByGeometryColor(polySrfc,
Color.ByARGB(255,225,185,145));

Conclusion

Once the initial massing and overall design direction have been established, computational tools can be further utilized to delve into the finer details of the design process. Here's how this iterative approach could unfold:

1. Division into Functional Sub-volumes: Computational algorithms can be employed to divide the enclosed volumes into functional sub-volumes based on programmatic requirements and spatial relationships. This process takes into account factors such as room sizes, adjacency preferences, and circulation patterns.

2. Analysis of Circulation, Lighting, and Ventilation: Computational simulations can be conducted to analyze circulation patterns within the space, ensuring efficient movement between rooms and areas. Lighting and ventilation analyses can also be performed to optimize natural light penetration and airflow distribution within the building, enhancing occupant comfort and energy efficiency.

3. Creation of Openings and Apertures: Based on the results of the analysis, computational algorithms can generate openings such as doors, windows, and other apertures in strategic locations within the building envelope. These openings are placed to facilitate desirable views, maximize daylighting, and promote natural ventilation while maintaining the overall integrity of the design.

4. Iterative Viewing Exercises: After creating openings and apertures, designers can conduct iterative viewing exercises from each aperture to assess the visual connections, sightlines, and framing of surrounding views. This process allows for refinement and optimization of the building's orientation and fenestration to capture desired vistas and enhance the overall spatial experience.

By employing computational tools throughout the design process, architects can iteratively refine their designs, optimize performance criteria, and create spaces that are not only functional and efficient but also responsive to their context and users' needs. This integrated approach fosters innovation and enables designers to explore new possibilities in architectural design.

23KB

vantage.dyn

// Peak
height = 30;
coneStart = Point.ByCoordinates
(0,0,0);
coneEnd = Point.ByCoordinates
	(0,0,height);
peak = GeometryColor.ByGeometryColor
	(Cone.ByPointsRadius
	(coneStart, coneEnd, 25),
	Color.ByARGB(255,55,60,55));


// Coastline
coast = PolyCurve.ByPoints
	(Point.ByCoordinates
		([50,70,90,60,50,30,0,-50],
		[-50,0,25,50,80,60,70,50]));

// Base
base = PolyCurve.ByPoints
	(Point.ByCoordinates
		([50,70,90,60,50,30,0,-50,-50],
		[-50,0,25,50,80,60,70,50,-50]),
		true)
	.ExtrudeAsSolid(0.35);
baseClrd = GeometryColor.ByGeometryColor
	(base,Color.ByARGB(255,200,200,135));

// Water
water = GeometryColor.ByGeometryColor(
	Surface.ByLoft(
		[coast,coast.Offset(300)]),
		Color.ByARGB(50,75,205,235));

// Builing Mass
site = Rectangle.ByCornerPoints
	(Point.ByCoordinates
		([20,20,50,50],
		[50,30,30,50]));
mass = site.ExtrudeAsSolid(20);

// Color Solid
GeometryColor.ByGeometryColor(mass,
Color.ByARGB(255,225,185,145));
GeometryColor.ByGeometryColor(coast.Extrude(0.5).Thicken(0.5),
Color.ByARGB(255,0,0,255));

// Sight Lines
eye = coneEnd;
coastVertices = coast.Points;
sightLines = Line.ByStartPointEndPoint
	(eye, coastVertices);

cuttingTool = Surface.ByLoft
	(sightLines);
GeometryColor.ByGeometryColor(
	cuttingTool, Color.ByARGB(200,190,190,190));
massIntersect = mass.Intersect(cuttingTool)[0];
perimeterCrvs = massIntersect.PerimeterCurves();
perimeterPnts = Curve.PointAtParameter
	(perimeterCrvs<1>,(0..0.3..#10));
perimeterNrmls = Surface.NormalAtPoint
	(massIntersect,perimeterPnts)
	.Reverse();
projectedPnts = Point.Project
	(perimeterPnts, Plane.XY(), perimeterNrmls);
projectedLins = Line.ByStartPointEndPoint
	(perimeterPnts,
	List.Flatten(projectedPnts<1>,-1));
projectedSrfc = Surface.ByLoft(projectedLins);

polySrfc = PolySurface.ByJoinedSurfaces(
List.Flatten([massIntersect,projectedSrfc],-1));

GeometryColor.ByGeometryColor(polySrfc,
Color.ByARGB(255,225,185,145));


//
// Faceted Trim
//
// Cutting Tool
cuttingTool1 = Surface.ByRuledLoft
	(sightLines);
GeometryColor.ByGeometryColor(
	cuttingTool1, Color.ByARGB(200,190,190,190));

// Trim Solid
trimmedSolid1 = Solid.Trim
	(mass,
	cuttingTool1,
	Point.ByCoordinates(20,50,20));

// Color Solid
GeometryColor.ByGeometryColor(trimmedSolid1,
Color.ByARGB(255,225,185,145));


//
//Smooth Trim
//
// Cutting Tool
cuttingTool2 = Surface.ByLoft
	(sightLines);
GeometryColor.ByGeometryColor(
	cuttingTool2, Color.ByARGB(200,190,190,190));

// Trim Solid
trimmedSolid2 = Solid.Trim
	(mass,
	cuttingTool2,
	Point.ByCoordinates(20,50,20));

// Color Solid
GeometryColor.ByGeometryColor(trimmedSolid2,
Color.ByARGB(255,225,185,145));


//
//Faceted Surface
//
// Cutting Tool
cuttingTool3 = Surface.ByRuledLoft
	(sightLines);
GeometryColor.ByGeometryColor(
	cuttingTool3, Color.ByARGB(200,190,190,190));

// Top Surface
massExtents3 = mass.Intersect(cuttingTool3);

// Thicken Surface
massThicken3 = massExtents3.Thicken(-50,false);

// Trim Solid
trimmedSolid3 = Solid.Trim
	(Solid.ByUnion(massThicken3),
	Plane.XY(),
	Point.ByCoordinates(20,50,-20));

// Color Solid
GeometryColor.ByGeometryColor(trimmedSolid3,
Color.ByARGB(255,225,185,145));


//
//Smooth Surface
//
cuttingTool4 = Surface.ByLoft
	(sightLines);
GeometryColor.ByGeometryColor(
	cuttingTool4, Color.ByARGB(200,190,190,190));
massIntersect4 = mass.Intersect(cuttingTool4)[0];
perimeterCrvs4 = massIntersect4.PerimeterCurves();
perimeterPnts4 = Curve.PointAtParameter
	(perimeterCrvs4<1>,(0..0.3..#10));
perimeterNrmls4 = Surface.NormalAtPoint
	(massIntersect4,perimeterPnts4)
	.Reverse();
projectedPnts4 = Point.Project
	(perimeterPnts4, Plane.XY(), perimeterNrmls4);
projectedLins4 = Line.ByStartPointEndPoint
	(perimeterPnts4,
	List.Flatten(projectedPnts4<1>,-1));
projectedSrfc4 = Surface.ByLoft(projectedLins4);

polySrfc4 = PolySurface.ByJoinedSurfaces(
List.Flatten([massIntersect4,projectedSrfc4],-1));

GeometryColor.ByGeometryColor(polySrfc4,
Color.ByARGB(255,225,185,145));