WF 05
Attractor Fields
Grasshopper · Dispatch & Remap → Line Field
Length2 sessions
Site50 × 50 ft
LogicDispatch · Remap
DueThu Nov 5 Thu Nov 12
Learning Objectives
  • Design as a rule
  • Thresholds and gradients as spatial rules
AssignmentThree meadow garden options — driven by ecology, experience, or both — built on the Session 2 definition plus any Rhino objects they need (a wall, a landform), submitted as one 11 × 17 sheet of three isometric views, each with a name and a short caption explaining its concept.
Submit to Miro board Password: "c*****2026", shared via email
Rhino
→
Populate 2D
→
Rule
→
Line Field
A flat meadow. Two given rules encode two landscape conditions — a mown path, and wet areas. Then you design a meadow garden of your own, from ecology, experience, or both.
This workflow introduces the core logic of parametric design: write the rule first, then build it in nodes.
Session 1 — Mowing Path
▶ Video Walkthrough — Steps 01–04
A narrated recording of Steps 01–04 and the optional landform, with chapters and captions (CC). It varies from the text in places: Random's N stays at Count (an on-screen note gives the proper wiring), and the mowed lines are 0.2 ft.
Open on YouTube for 1080p ↗
A Pseudocode First On paper — no computers
Before opening Grasshopper, write this rule on paper:
FOR EACH plant in meadow:
  IF distance to path < mowing width
    THEN height = mowed (short)
  ELSE height = unmowed (tall, random)
Identify: what is the input, what is the condition, what are the two outputs.
01 Set Up the Meadow GH
Construct the site boundary in Grasshopper — 50 × 50 ft. No need to draw in Rhino:
  • Rectangle → set X and Y domains to 0 to 50 (use a Construct Domain or a Panel)
  • Populate 2D → the Rectangle as region
  • Count slider → start at 1000
  • Seed slider → controls the random distribution
+ Optional — Meadow on a Landform Rhino GH
Grow the meadow on a landform instead of flat ground — your WF04 surface, or a new one:
  • Reference the landform into GH with a Brep parameter. Make it larger than the 50 × 50 rectangle so every point lands on it.
  • Pull Point → points = Populate 2D points, geometry = landform. Its Closest Point output is the meadow on the ground, whether the ground sits above or below the flat points.
  • Use these Closest Points everywhere Populate 2D points go below
  • Bring the path and the attractors down too: Project (Curve › Util) for curves, B = landform; Pull Point for the attractor points. Pull Point measures in 3D, so a flat path under raised ground reads as far away and the mown strip disappears. Doing this in GH keeps them live when you move the originals.
  • A dashed wire means the data sits in several lists. Right-click the output and Flatten it.
02 Random Heights (Unmowed) GH
Give every plant a random unmowed height:
  • Random → domain via a Panel typed 2 to 6.0 (grass height range); set Number (N) to the same Count as Populate 2D
  • Line SDL → start = Populate 2D points, direction = unit Z, length = Random
You now have a meadow — a field of vertical lines of varying height.
03 Draw + Measure the Path Rhino GH
In Rhino, draw a curve across the site — polyline or arc. Reference it into GH with a Curve parameter, then measure how far each plant sits from it:
  • Pull Point → input points = Populate 2D points, geometry = path curve
  • Use the Distance output directly — one component does both
Same component as the Session 2 wet areas — Pull Point pulls to any geometry (curve here, points there) and returns the distance.
04 Apply the Rule — Dispatch GH
Split the meadow into mown and unmown by the threshold:
  • Larger Than → A = distance to path, B = mowing width slider (start at 2)
  • Dispatch → data = Populate 2D points, pattern = Larger Than → List A = unmowed points, List B = mowed points
  • Unmowed: rewire the Step 02 Line SDL → start = List A. Feed List Length of List A into Random's N, so each unmowed plant gets exactly one height
  • Mowed: a second Line SDL → start = List B, direction = unit Z, length = a short Length slider (0.5)
Only the points are dispatched. Random's N has to match the List A count — if it stays at Count, the extra heights stack up as hidden lines on the last unmowed plant. List A points carry forward into Session 2. End of Session 1.
▸ Hint Session 1
⚠
Reference the curves and the boundary from Rhino. The .gh files carry the components only. After opening one, right-click each Curve parameter → Set one Curve, and pick your own geometry in Rhino.
Rhino viewport showing the mown path through the meadow
Viewport — mown path through the meadow
Grasshopper definition for the mowing path rule
Grasshopper definition — the full mowing-path rule
↓ Download example definition — WF05_mow.gh ↓ In-class demo — WF05_demo_session1.gh
Session 2 — Wet Areas
▶ Video Walkthrough — Steps 05–08
A narrated recording of Steps 05–06, ending on the finished heights, then a recap of both sessions, with chapters and captions (CC). It runs on the landform version (WF05_mow_water_landform.gh in the Hint below) with Max Radius 18, Height Near 5, Height Far 0.2.
Open on YouTube for 1080p ↗
B Pseudocode First On paper — no computers 
FOR EACH plant in meadow:
  height = remap(distance to nearest wet area, 0 → max, tall → short)
Close to a wet area = tall (wet, lush). Far from a wet area = short (dry).
05 Place Wet-Area Attractors Rhino GH
In Rhino, place 2–4 point objects on the site — these are the wet area locations. Reference them into GH with a Point parameter. Then find the nearest wet area for each unmowed plant:
  • Pull Point → input points = List A points (unmowed, from Step 04 Dispatch), geometry = wet area attractors
  • Use the Distance output directly, same as Step 03 — distance from each unmowed plant to its nearest wet area
06 Remap to Height GH
Turn distance into a height gradient, capped at a maximum influence radius:
  • Three sliders: Max Radius (default 15 ft), Height Near (default 9), Height Far (default 1)
  • Minimum → A = distances (Pull Point D), B = Max Radius slider → output = capped distances (GH broadcasts the single slider value across the whole list)
  • Construct Domain (source) → A = 0, B = Max Radius → fixed source domain
  • Construct Domain (target) → A = Height Near, B = Height Far → target domain
  • Remap Numbers → values = output from Minimum, source = source domain, target = target domain
Plants inside the radius get a gradient; plants outside all map to exactly Height Far. Moving a wet-area point creates a visible zone with a clear edge between lush and dry.
Remap in four rows: distances to the nearest wet area, capped at 15 by Minimum, remapped from 0 to 15 onto heights 9 to 1, drawn as grass lines 1 · Distance to the nearest wet area (Pull Point D) 0 4 9 13 24 38 ft 2 · Minimum, B = Max Radius 15: farther than 15 counts as 15 150 24 and 38 both become 15 3 · Remap Numbers: each value keeps its place, source 0 → 15 onto target 9 → 1 source = Construct Domain(0, Max Radius) target = Construct Domain(Height Near, Height Far) 0 9 4 6.9 9 4.2 13 2.1 15 1 Near Far 4 · Line SDL: length = remapped height wet area
Six plants, with the page defaults (Max Radius 15, Height Near 9, Height Far 1). Every plant past 15 ft lands on Height Far. Remap keeps each value’s place along its domain; the target runs 9 down to 1, so the near end gets the tallest height. Type Height Near smaller than Height Far to flip it. The video uses 18, 5 and 0.2.
07 Draw Plant Heights GH
Same as Session 1 — draw each unmowed plant as a vertical line, length = remapped height:
  • Line SDL → start = List A points (unmowed), direction = unit Z, length = remapped height
  • The remapped height replaces Random
  • The mowed branch (List B, 0.5) stays as it is
Tall lines near wet areas, short lines further away. The gradient reads immediately in the viewport.
08 Preview + Adjust Rhino
  • Move a wet area point in Rhino — the tall cluster shifts live
  • Add or remove wet area points — each makes a new zone of lush growth
  • Slide Height Near or Height Far to change the height contrast live
▸ Hint Session 2
Rhino viewport showing the meadow with mown path and wet-area attractor points — taller plants near the wet areas
Viewport — mown path plus wet-area gradient; plants taller near the attractor points
Grasshopper definition for the combined mowing-path and wet-area rules
Grasshopper definition — the full mow + wet-area rule
↓ Download example definition — WF05_mow_water.gh ↓ On a landform — WF05_mow_water_landform.gh ↓ In-class demo — WF05_demo_session2.gh
On Your Own — Meadow Garden
09 Design a Meadow Garden GH
Design three garden options on your Session 2 definition, from ecology, experience, or both. Use the same components with new logic:
  • Swap the attractor: points, a curve, or the site boundary
  • Flip the direction: short near the attractor
  • Use Dispatch where you used Remap, or the reverse
  • Remove plants: Dispatch, then draw one list only
Ecology. Reference: Teresa Galí-Izard, Arquitectura Agronomía.
  • Tree shade — trunk points; short in the shade, tall in the open. Remap, flipped.
  • Stream corridor — a stream curve; tall on the banks, short upland. Remap.
  • Deer browsing — bedding points; grazed short inside a radius. Dispatch.
  • Rock outcrops — bedrock points; nothing grows inside a radius. Dispatch, draw the outside only.
  • Woodland edge — tall along the site boundary, open in the middle. Pull Point to the Rectangle + Remap.
Experience. Reference: Catherine Dee, Form and Fabric in Landscape Architecture (2001).
  • Enclosure — tall grass as walls, short grass as floor
  • Garden rooms — mown patches of different sizes, joined by the path
  • Circulation — a wide main path and narrow side paths, each with its own mowing width
  • Sequence and rhythm — open and enclosed in turn along the path; Divide Curve for attractor points
  • Threshold — a narrow gap in tall grass before a room
Both — e.g. a mown room at the wet area, walled by tall sedge.
Model Rhino objects as needed — a wall, a landform. Capture all three from the same view (Set View → SE Isometric), each with a name and a short caption.
Key Concepts
Populate 2D vs. grid — Populate 2D distributes points organically within a boundary. The Seed slider changes the distribution without changing the count. It reads as a natural meadow, not a tile pattern.
Dispatch vs. Remap — Dispatch encodes a binary rule (mow / no mow). Remap encodes a continuous gradient (tall near water, short away). Most landscape conditions are gradients; the binary is the readable edge.
Pull Point — works like Closest Point: for each input point, finds the nearest geometry in a set and returns its location. Used here to measure proximity to the nearest wet area across multiple attractors.
Line SDL — the same component used in Session 1. Start point, direction, length. Swapping the length input from Random to a Remap value is the only change — the drawing logic stays identical.
Pseudocode → Node Reference
PseudocodeGH component
for each plant in meadowPopulate 2D
distance to pathPull Point
if / elseLarger Than + Dispatch
one height per unmowed plantList Length → Random N
distance to nearest wet areaPull Point
remap to heightRemap Numbers
draw plantLine SDL
Tips
  • Write the rule on paper before touching a node. The pseudocode is the design.
  • Dispatch is the readable edge; Remap is the gradient. Know which one the condition wants.
  • Set hints and watch the preview live — drag a slider and read the change before moving on.
LAAR 61400 — Representation & Computation IWorkflow 05 of 06