Skip to content
TheChatArchiveThe Chat Archive
gpt-4.1-mini-2025-04-14· OpenAIAi2 WildChat-4.8M (AI2)

give a code in p5js to visualize a tree

  1. User

    give a code in p5js to visualize a tree

  2. Assistant

    Certainly! Below is a simple example of how to visualize a fractal tree using p5.js. This code draws a recursive tree where each branch splits into two smaller branches:

    function setup() {
      createCanvas(600, 400);
      background(220);
      angleMode(DEGREES);
      stroke(70, 40, 20);
      noLoop();
    }
    
    function draw() {
      background(220);
      // Start drawing the tree from the bottom center of the canvas
      translate(width / 2, height);
      // Draw the tree with an initial length and angle
      branch(100);
    }
    
    function branch(len) {
      strokeWeight(map(len, 2, 100, 1, 10)); // Thicker branches at base
      line(0, 0, 0, -len);  // Draw branch upwards
    
      // Move to the end of the branch
      translate(0, -len);
    
      // Recursive stop condition
      if (len > 10) {
        push();  // Save current transformation state
        rotate(30);  // Rotate right
        branch(len * 0.67);
        pop();   // Restore state
    
        push();
        rotate(-30);  // Rotate left
        branch(len * 0.67);
        pop();
      }
    }
    

    How it works:

    • branch(len) draws a branch of length len.
    • At the end of each branch, it recursively draws two smaller branches, each rotated by ±30 degrees.
    • The recursion stops when the branch length is less than or equal to 10.
    • Stroke weight decreases with branch length to simulate tapering branches.

    You can paste this code into the p5.js web editor (https://editor.p5js.org/) and run it to see the tree visualization. Let me know if you want it more interactive or detailed!

  3. User

    add leaves to the above code

  4. Assistant

    Sure! I'll add simple green leaves at the tips of the smallest branches. We'll draw small green ellipses (leaves) when the branch length is less than or equal to the stopping length (here 10).

    Here's the updated code:

    function setup() {
      createCanvas(600, 400);
      background(220);
      angleMode(DEGREES);
      stroke(70, 40, 20);
      noLoop();
    }
    
    function draw() {
      background(220);
      translate(width / 2, height);
      branch(100);
    }
    
    function branch(len) {
      strokeWeight(map(len, 2, 100, 1, 10)); // Thicker base branches
      line(0, 0, 0, -len);
      translate(0, -len);
    
      if (len > 10) {
        push();
        rotate(30);
        branch(len * 0.67);
        pop();
    
        push();
        rotate(-30);
        branch(len * 0.67);
        pop();
      } else {
        // Draw leaves at the end branches
        noStroke();
        fill(34, 139, 34, 180);  // a semi-transparent green
        ellipse(0, 0, 12, 20);
        ellipse(-5, 5, 12, 20);
        ellipse(5, 5, 12, 20);
        fill(50, 205, 50, 150);
        ellipse(0, 0, 8, 15);
      }
    }
    

    What changed:

    • When the branch length is <=10, instead of continuing recursion, we draw leaf shapes (ellipses) around the tip.
    • Leaves have green fill color and no stroke for a soft look.

    Run this in the p5.js editor to see a tree with leaves at its tips! Let me know if you'd like to customize leaf colors, shapes, or add animation.

  5. User

    make it large leaves with each leaves stating issues like money, distance , langauage

  6. Assistant

    Got it! I'll modify the code so that at each tip where leaves are drawn, we'll draw large leaves that contain text inside them representing various issues like "Money", "Distance", "Language".

    Here’s how we'll do it:

    • Define an array of issues: ["Money", "Distance", "Language"].
    • For each leaf at the tip, display one issue.
    • To keep the text readable, we'll draw a large ellipse leaf and write the issue text centered inside it.
    • We'll cycle through the issues for each leaf drawn.

    Here's the updated code:

    let issues = ["Money", "Distance", "Language"];
    let issueIndex = 0;
    
    function setup() {
      createCanvas(800, 600);
      background(220);
      angleMode(DEGREES);
      stroke(70, 40, 20);
      noLoop();
      textAlign(CENTER, CENTER);
      textSize(14);
      rectMode(CENTER);
    }
    
    function draw() {
      background(220);
      translate(width / 2, height);
      issueIndex = 0;  // Reset at start of each draw
      branch(120);
    }
    
    function branch(len) {
      strokeWeight(map(len, 2, 120, 1, 12));
      line(0, 0, 0, -len);
      translate(0, -len);
    
      if (len > 15) {
        push();
        rotate(30);
        branch(len * 0.67);
        pop();
    
        push();
        rotate(-30);
        branch(len * 0.67);
        pop();
      } else {
        // Draw a large leaf with an issue text inside
        noStroke();
    
        // Leaf shape: ellipse with a pointed "tip" (approximate)
        fill(34, 139, 34, 220);
        ellipse(0, 0, 80, 40);
    
        // Optional leaf tip - small triangle on one side
        fill(0, 100, 0, 180);
        triangle(-40, 0, -50, -10, -50, 10);
    
        // Text inside leaf
        fill(255);
        textSize(16);
        let issue = issues[issueIndex % issues.length];
        issueIndex++;
        text(issue, 0, 0, 70, 30);  // Wrap text in leaf size
      }
    }
    

    What this does:

    • Leaves at branch tips are large green ellipses with a small triangle to simulate a leaf tip.
    • Inside each leaf, centered white text shows an issue from the array.
    • Leaves cycle through "Money", "Distance", and "Language" in order.
    • Increased canvas size and branch length to fit larger leaves.

    Try this in the p5.js online editor, and you should see a recursively drawn tree with big labeled leaves at the tips.

    If you want me to add more leaves or issues, or position the issue text differently, just ask!

  7. User

    make these trees into 5 trees

  8. Assistant

    Sure! To make 5 trees spaced evenly across the canvas, we can draw the same recursive tree 5 times at different horizontal positions.

    Here’s the updated code that draws 5 trees side by side:

    let issues = ["Money", "Distance", "Language"];
    let issueIndex = 0;
    
    function setup() {
      createCanvas(1000, 600);
      background(220);
      angleMode(DEGREES);
      stroke(70, 40, 20);
      noLoop();
      textAlign(CENTER, CENTER);
      textSize(16);
      rectMode(CENTER);
    }
    
    function draw() {
      background(220);
    
      issueIndex = 0;  // Reset before drawing all trees
    
      let treeCount = 5;
      let spacing = width / (treeCount + 1);
    
      for (let i = 1; i <= treeCount; i++) {
        push();
        translate(spacing * i, height);
        branch(120);
        pop();
      }
    }
    
    function branch(len) {
      strokeWeight(map(len, 2, 120, 1, 12));
      line(0, 0, 0, -len);
      translate(0, -len);
    
      if (len > 15) {
        push();
        rotate(30);
        branch(len * 0.67);
        pop();
    
        push();
        rotate(-30);
        branch(len * 0.67);
        pop();
      } else {
        noStroke();
    
        fill(34, 139, 34, 220);
        ellipse(0, 0, 80, 40);
    
        fill(0, 100, 0, 180);
        triangle(-40, 0, -50, -10, -50, 10);
    
        fill(255);
        textSize(16);
        let issue = issues[issueIndex % issues.length];
        issueIndex++;
        text(issue, 0, 0, 70, 30);
      }
    }
    

    Explanation:

    • The canvas width is 1000px to comfortably space 5 trees.
    • We calculate an even horizontal spacing: spacing = width / (treeCount + 1).
    • For each tree, we translate to (spacing * i, height) and draw the tree.
    • issueIndex is reset before drawing all trees and incremented at each leaf so that issues keep cycling across all 5 trees.

    Run this in p5.js editor and you’ll see 5 recursive trees in a row, each with labeled leaves.

    If you want different issues for each tree, or more customization, just ask!

  9. User

    Make it trees with only leaves with the problems once and in different spaces not linear connected through roots of color red, blue, pink and purple

  10. Assistant

    Understood! You want to visualize 5 separate "trees" that aren't connected via roots, and instead of branches, just leaves placed scattered randomly (not in a line), each leaf showing a unique problem (issue) exactly once. Each tree should have a different root color (red, blue, pink, purple, etc.).

    So effectively:

    • 5 groups of leaves scattered spatially (not connected by branches).
    • Each leaf displays one unique issue (problems shown once only across all trees).
    • Roots are points of different colors under each tree, but no connecting branches.
    • Leaves placed around the root in a cluster.

    Here is the p5.js code that implements this:

    // List of problems (one per leaf)
    let problems = [
      "Money",
      "Distance",
      "Language",
      "Time",
      "Fear",
      "Trust",
      "Culture",
      "Access",
      "Support",
      "Info"
    ];
    
    // Colors for each tree root
    let rootColors = [
      [255, 0, 0],      // Red
      [0, 0, 255],      // Blue
      [255, 20, 147],   // Pink (Deep Pink)
      [128, 0, 128],    // Purple
      [0, 128, 128]     // Teal
    ];
    
    // Each tree will have some leaves assigned, distribute problems evenly
    let trees = [];
    
    function setup() {
      createCanvas(1000, 600);
      background(240);
      noLoop();
      textAlign(CENTER, CENTER);
      textSize(14);
      rectMode(CENTER);
      
      // Divide problems evenly among 5 trees
      let problemsPerTree = Math.ceil(problems.length / rootColors.length);
      
      for (let i = 0; i < rootColors.length; i++) {
        let startIdx = i * problemsPerTree;
        let endIdx = min(startIdx + problemsPerTree, problems.length);
        let leafProblems = problems.slice(startIdx, endIdx);
        
        // For each tree: store root pos, color, and assigned problems
        let tree = {
          rootX: random(100 + i * 180, 100 + i * 180 + 150), // spread horizontally
          rootY: height - 100,
          color: rootColors[i],
          leaves: leafProblems
        };
        trees.push(tree);
      }
    }
    
    function draw() {
      background(240);
    
      // Draw each tree root and leaves
      for (let t = 0; t < trees.length; t++) {
        let tree = trees[t];
        
        // Draw root as a circle with root color
        noStroke();
        fill(tree.color);
        ellipse(tree.rootX, tree.rootY, 20, 20);
        
        // Draw leaves around root
        // For each leaf, position randomly within a radius around root
        for (let i = 0; i < tree.leaves.length; i++) {
          let leafX = tree.rootX + random(-80, 80);
          let leafY = tree.rootY - random(50, 150);
          
          drawLeaf(leafX, leafY, tree.leaves[i]);
        }
      }
    }
    
    // Draw a large leaf with text inside at (x, y)
    function drawLeaf(x, y, issue) {
      push();
      translate(x, y);
      noStroke();
      
      // Leaf shape - ellipse with a pointed tip (triangle)
      fill(34, 139, 34, 220);
      ellipse(0, 0, 90, 50);
      fill(0, 100, 0, 180);
      triangle(-45, 0, -55, -15, -55, 15);
      
      // Issue text
      fill(255);
      textSize(14);
      text(issue, 0, 0, 80, 40);
      pop();
    }
    

    Features:

    • 5 tree roots spaced horizontally but randomly jittered.
    • Each root is a colored circle (red, blue, pink, purple, teal).
    • Leaves with large green ellipse shape shade displayed around the root within a radius.
    • Each leaf shows a unique problem text exactly once across all trees.
    • Leaves placed with some random scatter in a vertical cluster above each root.
    • No branch connections, just roots and leaves.

    Open this in the p5.js Web Editor and you’ll see the visualization you described.

    If you want me to tweak leaf shapes, add interactivity, or arrange leaves differently, just ask!

  11. User

    no 5 separate trees that are connected to each other via roots of multiple colors and scattered randomly

  12. Assistant

    Got it! You want 5 separate trees positioned randomly (not in a line), each with leaves representing unique problems (issues, once each), and the trees' roots connected to each other by colored root lines (multiple colors).

    Key points:

    • 5 trees scattered randomly on the canvas.
    • Each tree root is a colored circle of a unique color.
    • Leaves cluster around each tree root, each leaf having one unique issue (no repeats).
    • The roots are connected to each other by curved colored "root" lines with multiple colors.
    • The root connections form a network between the 5 trees.

    Here's a complete p5.js sketch implementing exactly that:

    // Problems (one each)
    let problems = [
      "Money", "Distance", "Language", "Time", "Fear",
      "Trust", "Culture", "Access", "Support", "Info"
    ];
    
    // Colors for each tree root (5 colors)
    let rootColors = [
      [255, 0, 0],      // Red
      [0, 0, 255],      // Blue
      [255, 20, 147],   // Pink (Deep Pink)
      [128, 0, 128],    // Purple
      [0, 128, 128]     // Teal
    ];
    
    let trees = [];
    let connectionColors = [
      [255, 100, 100, 180],
      [100, 100, 255, 180],
      [255, 100, 200, 180],
      [180, 100, 180, 180],
      [100, 180, 180, 180],
    ];
    
    function setup() {
      createCanvas(1000, 700);
      background(240);
      noLoop();
      textAlign(CENTER, CENTER);
      textSize(14);
      rectMode(CENTER);
      
      // Initialize trees:
      // random positions scattered 
      for (let i = 0; i < rootColors.length; i++) {
        trees.push({
          rootX: random(150, width - 150),
          rootY: random(height/2 + 50, height - 100),
          color: rootColors[i],
          leaves: []
        });
      }
      
      // Distribute problems evenly (unique)
      let problemsPerTree = Math.ceil(problems.length / trees.length);
      for (let i = 0; i < trees.length; i++) {
        let start = i * problemsPerTree;
        let end = min(start + problemsPerTree, problems.length);
        trees[i].leaves = problems.slice(start, end);
      }
    }
    
    function draw() {
      background(240);
    
      // Draw root connections (curved lines) between trees
      drawRootConnections();
      
      // Draw each tree: root + leaves
      trees.forEach(tree => {
        drawTree(tree);
      });
    }
    
    // Draw connections between every pair of roots with colored bezier curves
    function drawRootConnections() {
      strokeWeight(6);
      noFill();
      // Connect all pairs
      for (let i = 0; i < trees.length; i++) {
        for (let j = i + 1; j < trees.length; j++) {
          // Color chosen by sum mod connectionColors length to vary color
          let colorIndex = (i + j) % connectionColors.length;
          let c = connectionColors[colorIndex];
          
          stroke(c[0], c[1], c[2], c[3]);
          
          // Draw curved line between trees[i] and trees[j]
          // Control points add organic shape to root
          let x1 = trees[i].rootX;
          let y1 = trees[i].rootY;
          let x2 = trees[j].rootX;
          let y2 = trees[j].rootY;
          
          let cx1 = x1;
          let cy1 = (y1 + y2) / 2 + random(-80, 80);
          
          let cx2 = x2;
          let cy2 = (y1 + y2) / 2 + random(-80, 80);
          
          bezier(x1, y1, cx1, cy1, cx2, cy2, x2, y2);
        }
      }
    }
    
    // Draw a single tree: root and leaves scattered around it
    function drawTree(tree) {
      // Draw root circle
      noStroke();
      fill(tree.color);
      ellipse(tree.rootX, tree.rootY, 30, 30);
      
      // Draw leaves cluster (scattered above root)
      tree.leaves.forEach(issue => {
        let leafX = tree.rootX + random(-90, 90);
        let leafY = tree.rootY - random(60, 160);
        drawLeaf(leafX, leafY, issue);
      });
    }
    
    // Leaf shape and text
    function drawLeaf(x, y, issue) {
      push();
      translate(x, y);
      noStroke();
      
      // Leaf ellipse
      fill(34, 139, 34, 230);
      ellipse(0, 0, 100, 55);
      
      // Leaf tip
      fill(0, 100, 0, 180);
      triangle(-50, 0, -65, -18, -65, 18);
      
      // Text
      fill(255);
      textSize(14);
      text(issue, 0, 0, 90, 45);
      
      pop();
    }
    

    How it works:

    • The 5 trees are placed randomly but avoid being too close to edges.
    • Each tree root is a solid circle colored uniquely.
    • Each tree’s leaves (problems) are scattered randomly around the root (above), large green ellipses with text.
    • The roots of all trees are connected pairwise with bezier curves in varying translucent colors to simulate intertwined roots networks.
    • The connection colors are semi-transparent and vary for multiple connections.

    What to expect

    Run this sketch and you will see a “forest” of 5 separated grouped leaves trees, connected underground with colorful curved root lines, representing a network.

    If you want me to add something like hovering tooltips, clickable leaves, or animation of roots growing, just ask!

  13. User

    can you make it more like a tree

  14. Assistant

    Absolutely! To make the visualization more like actual trees — where each tree has:

    • a visible trunk extending upwards from the root,
    • several branches splitting from the trunk,
    • and leaves clustered at the branch tips (with problem texts),
    • the roots of the 5 trees connected underground by beautifully curved colored root lines,

    I will enhance the previous sketch to include trunks and branches, and keep the root network below.


    What I'll do:

    • Each tree will have a vertical trunk (thicker near the root).
    • From the trunk, multiple recursive branches split (using simple fractal branching).
    • Leaves are only drawn at branch tips.
    • Problems still assigned uniquely to leaves, distributed across all trees.
    • Roots stay connected below by colorful curved lines.
    • Trees remain scattered randomly on the canvas.

    Here's the improved p5.js sketch:

    let problems = [
      "Money", "Distance", "Language", "Time", "Fear",
      "Trust", "Culture", "Access", "Support", "Info"
    ];
    
    let rootColors = [
      [255, 0, 0],      // Red
      [0, 0, 255],      // Blue
      [255, 20, 147],   // Pink (Deep Pink)
      [128, 0, 128],    // Purple
      [0, 128, 128]     // Teal
    ];
    
    let connectionColors = [
      [255, 100, 100, 180],
      [100, 100, 255, 180],
      [255, 100, 200, 180],
      [180, 100, 180, 180],
      [100, 180, 180, 180],
    ];
    
    // Each tree will have a root position, assigned color, and leaves (problem text)
    let trees = [];
    
    let maxDepth = 5; // recursion depth for branches
    
    // For distributing problems to leaves across trees & branches
    let assignedProblems = [];
    let problemIndex = 0;
    
    function setup() {
      createCanvas(1000, 700);
      background(240);
      noLoop();
      textAlign(CENTER, CENTER);
      rectMode(CENTER);
    
      // Place the 5 trees randomly (avoid edges)
      for (let i = 0; i < rootColors.length; i++) {
        trees.push({
          rootX: random(150, width - 150),
          rootY: random(height / 2 + 100, height - 100),
          color: rootColors[i],
          leaves: []
        });
      }
    
      // Assign problems evenly across leaves of all trees
      // Each tree approximately gets equal number of leaf problems
      let problemsPerTree = Math.ceil(problems.length / trees.length);
    
      // Initialize leaves arrays now empty, will fill during branch drawing
      for (let t = 0; t < trees.length; t++) {
        trees[t].leaves = [];
      }
    }
    
    function draw() {
      background(240);
    
      // Draw root connections first
      drawRootConnections();
    
      // Draw each tree: root, trunk, branches & leaves
      problemIndex = 0; // reset problem assignment across all leaves
    
      trees.forEach(tree => {
        drawTree(tree);
      });
    }
    
    function drawRootConnections() {
      strokeWeight(6);
      noFill();
      for (let i = 0; i < trees.length; i++) {
        for (let j = i + 1; j < trees.length; j++) {
          let colorIndex = (i + j) % connectionColors.length;
          let c = connectionColors[colorIndex];
          stroke(c[0], c[1], c[2], c[3]);
    
          let x1 = trees[i].rootX;
          let y1 = trees[i].rootY;
          let x2 = trees[j].rootX;
          let y2 = trees[j].rootY;
    
          // Control points for smooth curves - organic root shapes
          let cx1 = x1;
          let cy1 = (y1 + y2) / 2 + random(-80, 80);
    
          let cx2 = x2;
          let cy2 = (y1 + y2) / 2 + random(-80, 80);
    
          bezier(x1, y1, cx1, cy1, cx2, cy2, x2, y2);
        }
      }
    }
    
    function drawTree(tree) {
      push();
      translate(tree.rootX, tree.rootY);
    
      // Draw root circle
      noStroke();
      fill(tree.color);
      ellipse(0, 0, 30, 30);
    
      // Draw trunk - vertical line upwards
      stroke(tree.color);
      strokeWeight(10);
      line(0, 0, 0, -120);
    
      // Draw branches recursively starting at top of trunk
      push();
      translate(0, -120);
      stroke(tree.color);
      branch(100, 0);
      pop();
    
      pop();
    }
    
    // Recursive branch function
    // len = length of branch
    // angle = current rotation angle from vertical
    function branch(len, angle, depth = 0) {
      strokeWeight(map(len, 10, 100, 2, 12));
      strokeCap(ROUND);
      push();
      rotate(angle);
      line(0, 0, 0, -len);
      translate(0, -len);
    
      if (len > 20 && depth < maxDepth) {
        // branch splits into 2 or 3 branches randomly
        let branches = random([2, 3]);
        
        for (let i = 0; i < branches; i++) {
          let branchAngle = map(i, 0, branches - 1, -40, 40) + random(-10,10);
          branch(len * 0.67, branchAngle, depth + 1);
        }
      } else {
        // Draw leaf with problem text at branch tip
    
        // Assign problem if available
        let issue = (problemIndex < problems.length) ? problems[problemIndex] : " ";
        problemIndex++;
    
        drawLeaf(0, 0, issue);
      }
    
      pop();
    }
    
    // Draw leaf at position (x=0,y=0) relative to tree
    function drawLeaf(x, y, issue) {
      push();
      translate(x, y);
      noStroke();
    
      fill(34, 139, 34, 230);
      ellipse(0, 0, 100, 55);
    
      fill(0, 100, 0, 180);
      triangle(-50, 0, -65, -18, -65, 18);
    
      fill(255);
      textSize(14);
      text(issue, 0, 0, 90, 45);
    
      pop();
    }
    

    What you get:

    • 5 randomly positioned trees with trunks and branching structures.
    • Branches split 2 or 3 ways recursively up to depth 5.
    • Leaves with your unique problems appear at tips of branches.
    • Roots at base drawn as colored circles for each tree.
    • Colorful bezier "root network" lines connect all roots below ground.
    • Trees are visually separated but connected underground.

    Open this in the p5.js editor to see a natural-looking forest with individual trees connected by colorful roots, each tree displaying leaves labeled with unique problems.


    If you'd like me to:

    • change colors,
    • animate root growth,
    • add hover interaction or tooltips,
    • or adjust branch complexity,

    just let me know!

  15. User

    Make a tree in p5js with branches and green patch on top with 4 leaves enlarged and highlighted with problems like scarcity, water, air , dust.

  16. Assistant

    Certainly! Below is a p5.js sketch that draws a single tree with:

    • A trunk with branches,
    • A green “canopy” patch on top,
    • Exactly 4 large leaves on the canopy, each highlighted with a problem ("Scarcity", "Water", "Air", "Dust").

    The leaves are enlarged and labeled:

    function setup() {
      createCanvas(600, 600);
      background(220);
      angleMode(DEGREES);
      noLoop();
      textAlign(CENTER, CENTER);
      rectMode(CENTER);
    }
    
    function draw() {
      background(220);
    
      translate(width / 2, height);
    
      drawTrunkAndBranches(150);
    
      drawCanopy();
    
      // Draw highlighted leaves with problems
      let problems = ["Scarcity", "Water", "Air", "Dust"];
      // Positions relative to canopy center, spread around top
      let leafPositions = [
        createVector(-80, -260),
        createVector(-30, -280),
        createVector(30, -280),
        createVector(80, -260),
      ];
    
      for (let i = 0; i < problems.length; i++) {
        drawLeaf(leafPositions[i].x, leafPositions[i].y, problems[i]);
      }
    }
    
    // Draw the trunk and two main branches
    function drawTrunkAndBranches(trunkHeight) {
      stroke(101, 67, 33);
      strokeWeight(20);
    
      // Trunk
      line(0, 0, 0, -trunkHeight);
    
      // Branches
      push();
      translate(0, -trunkHeight);
    
      strokeWeight(12);
      
      // Left branch
      push();
      rotate(-35);
      line(0, 0, 0, -100);
      pop();
    
      // Right branch
      push();
      rotate(35);
      line(0, 0, 0, -100);
      pop();
    
      pop();
    }
    
    // Draw green canopy patch (ellipse)
    function drawCanopy() {
      noStroke();
      fill(34, 139, 34, 200);
      ellipse(0, -320, 250, 130);
    }
    
    // Draw a large leaf with text label at position x,y
    function drawLeaf(x, y, label) {
      push();
      translate(x, y);
      noStroke();
    
      // Leaf shape - ellipse + tip triangle
      fill(34, 139, 34);
      ellipse(0, 0, 120, 65);
    
      fill(0, 100, 0);
      triangle(-60, 0, -80, -20, -80, 20);
    
      // Highlight leaf border
      stroke(255, 204, 0);
      strokeWeight(4);
      noFill();
      ellipse(0, 0, 128, 75);
    
      // Text label
      noStroke();
      fill(255);
      textSize(18);
      text(label, 0, 0, 100, 50);
    
      pop();
    }
    

    How it looks:

    • A brown trunk with two thick main branches angling left and right.
    • A big green ellipse canopy on top.
    • Four large green leaves evenly spaced on the canopy.
    • Leaves have a glowing yellow border (highlight).
    • Each leaf shows a problem label in white text.

    You can run this as-is in p5.js web editor!

    If you want me to add animations, interactive tooltips, or more natural branch shapes, just ask!

  17. User

    leaves in spearate directions and visible

  18. Assistant

    Got it! I updated the sketch so the four large leaves spread out visibly in distinct directions around the canopy, each clearly separate and rotated outward from the canopy center. The leaves are bigger, rotated, and spaced nicely, so they don’t overlap, and each points in a different direction with labeled problem text visible.

    Here’s the improved code:

    function setup() {
      createCanvas(600, 600);
      background(220);
      angleMode(DEGREES);
      noLoop();
      textAlign(CENTER, CENTER);
      rectMode(CENTER);
    }
    
    function draw() {
      background(220);
    
      translate(width / 2, height);
    
      drawTrunkAndBranches(150);
    
      drawCanopy();
    
      // Four leaves with problems spaced in separate directions around canopy
      let problems = ["Scarcity", "Water", "Air", "Dust"];
    
      // Angles (degrees) where leaves point around canopy 
      let angles = [-75, -20, 20, 75]; 
    
      let radius = 120; // distance from canopy center
      
      for (let i = 0; i < problems.length; i++) {
        // Position for each leaf from canopy center (0, -320)
        let leafX = radius * cos(angles[i]);
        let leafY = -320 + radius * sin(angles[i]);
        drawLeaf(leafX, leafY, problems[i], angles[i]);
      }
    }
    
    // Draw the trunk and two main branches
    function drawTrunkAndBranches(trunkHeight) {
      stroke(101, 67, 33);
      strokeWeight(20);
    
      // Trunk
      line(0, 0, 0, -trunkHeight);
    
      // Branches
      push();
      translate(0, -trunkHeight);
    
      strokeWeight(12);
      
      // Left branch
      push();
      rotate(-35);
      line(0, 0, 0, -100);
      pop();
    
      // Right branch
      push();
      rotate(35);
      line(0, 0, 0, -100);
      pop();
    
      pop();
    }
    
    // Draw green canopy patch (ellipse)
    function drawCanopy() {
      noStroke();
      fill(34, 139, 34, 200);
      ellipse(0, -320, 250, 130);
    }
    
    // Draw a large leaf with text label at position x,y rotated by angle
    function drawLeaf(x, y, label, angle) {
      push();
      translate(x, y);
      rotate(angle);
    
      noStroke();
      // Leaf shape - ellipse + tip triangle
      fill(34, 139, 34);
      ellipse(0, 0, 120, 65);
    
      fill(0, 100, 0);
      triangle(-60, 0, -80, -20, -80, 20);
    
      // Highlight leaf border
      stroke(255, 204, 0);
      strokeWeight(4);
      noFill();
      ellipse(0, 0, 128, 75);
    
      // Text label (rotated opposite to leaf for readability)
      push();
      rotate(-angle);
      fill(255);
      noStroke();
      textSize(18);
      text(label, 0, 0, 100, 50);
      pop();
    
      pop();
    }
    

    What this does:

    • Leaves placed around the canopy at angles -75°, -20°, 20°, 75° (spread left to right).
    • Each leaf rotated to point outward with a nice visible orientation.
    • Text inside each leaf rotates back to be upright for easy reading.
    • Leaves are positioned to avoid overlap and clearly visible.

    You can run this version directly in the p5.js editor, and you’ll see the leaves clearly pointed off in 4 different directions from the green canopy on top of the tree.

    If you want me to adjust sizes, colors, or add animations/details, just let me know!