Agent-based Tectonics

Daniel Dennett once addressed how impressive the products of an algorithm, the underlying process always consists of nothing but a set of individually mindless steps succeeding each other without the help of intelligent supervision: they are “automatic” by definition: the workings of an automaton. This project states that algorithm is a new set of geometry, a new set of aesthetic with autonomous agents.

Low-poly Modeling

modularity to subdivision surface

low-poly modeling

Mesh vector field

extract vector field data for orienting planes

mesh vector field

Mesh initial processing

build vertex-colored meshes for scalar and vector data fields

mesh initial processing

Left: mesh with vector value
Right: mesh with scalar value

Agent System

a flocking agent system based on Craig Reynolds classical rules

1
public class AgentPlaneSimulation
2
{
3
    // ..........................    fields
4

15 collapsed lines
5
    //public double cNS;
6
    //public double cNT;
7
    public double PlaneRadius;
8
    public double NeighborhoodRadius;
9
    public double CohesionStrength;
10
    public double AlignmentStrength;
11
    public double SeparationStrength;
12
    public double FieldStrength;
13
    public double MaxForce;
14
    public double MeshSeekRadius;
15
    public double MeshStrength;
16
    public double SeekColorStrength;
17
    public double MaxSpeed;
18

19
    public AgentPlane[] agentPlanes;
20

21
    // ..........................    constructor
22

23
    public AgentPlaneSimulation(List<Point3d> P, List<Vector3d> V, double cNS, double cNT, double pR, double cI, double aI, double sI, double fI, double mF)
21 collapsed lines
24
    {
25

26
        //this.cNS = cNS;
27
        //this.cNT = cNT;
28
        this.PlaneRadius = pR;
29
        this.CohesionStrength = cI;
30
        this.AlignmentStrength = aI;
31
        this.SeparationStrength = sI;
32
        this.FieldStrength = fI;
33
        this.MaxForce = mF;
34
        this.MaxSpeed = 0.3;
35

36
        // build agent planes array
37
        agentPlanes = new AgentPlane[P.Count];
38

39
        Parallel.For(0, P.Count, i =>
40
        {
41
            agentPlanes[i] = new AgentPlane(P[i], V[i], this);
42
        });
43

44
    }
45

46
    public AgentPlaneSimulation(List<Point3d> P, List<Vector3d> V)
11 collapsed lines
47
    {
48
        // build agent planes array
49
        agentPlanes = new AgentPlane[P.Count];
50
        this.MaxSpeed = 0.1;
51

52
        Parallel.For(0, P.Count, i =>
53
        {
54
            agentPlanes[i] = new AgentPlane(P[i], V[i], this);
55
        });
56

57
    }
58

59
    // ..........................    methods
60

61
    public void Update()
39 collapsed lines
62
    {
63

64
        // . . . . . . . . . . environmental and stigmergic interactions
65

66
        // calculate field influence vector for agents
67

68
        foreach(AgentPlane ag in agentPlanes)
69
        {
70
            // clear neighbour list
71
            ag.neighbours.Clear();
72
            ag.neighTens.Clear();
73

74
            // calculate field vector from mesh
75
            // Eventhandler function for RTree search
76
            EventHandler<RTreeEventArgs> rTreeCallback = (object sender, RTreeEventArgs args) =>
77
            {
78
                ag.neighbours.Add(MEnvironment.Vertices[args.Id]);
79
                ag.neighTens.Add(TensorField[args.Id]);
80
            };
81

82
            MeshRTree.Search(new Sphere(MEnvironment.ClosestPoint(ag.O), MeshSeekRadius), rTreeCallback);
83

84
            // this resets the acceleration (or desired direction)
85
            // in case a different update sequence is implemented
86
            // remember to reset desired before calculating the new iteration
87
            ag.ResetDesired();
88
            ag.SeekMeshNeighbours();
89
            ag.SeekColor();
90
            ag.ComputeFieldAlign(ag.ComputeFieldVector(),FieldStrength);
91

92
        }
93

94
        // . . . . . . . . . . peer-to-peer interaction
95
        FLockRTree();
96

97
        // . . . . . . . . . . update position and direction
98
        UpdateAgentsDirection();
99

100
    }
101

102

103
    public void FLockRTree()
27 collapsed lines
104
    {
105
        // declare RTree
106
        RTree rTree = new RTree();
107

108
        // populate RTree
109
        for (int i = 0; i < agentPlanes.Length; i++)
110
            rTree.Insert(agentPlanes[i].O, i);
111

112
        // find neighbours for each agent
113
        foreach (AgentPlane agent in agentPlanes)
114
        {
115
            List<AgentPlane> neighbours = new List<AgentPlane>();
116

117
            EventHandler<RTreeEventArgs> rTreeCallback =
118
                (object sender, RTreeEventArgs args) =>
119
                {
120
                    if (agentPlanes[args.Id] != agent)
121
                        neighbours.Add(agentPlanes[args.Id]);
122
                };
123

124
            rTree.Search(new Sphere(agent.O, NeighborhoodRadius), rTreeCallback);
125

126
            // compute desired vector for each agent
127
            agent.ComputeDesiredNeighbours(neighbours);
128
        }
129

130
    }
131

132
    public void UpdateAgentsDirection()
9 collapsed lines
133
    {
134
        // here's one of my mods - update positions and velocities in parallel
135
        Parallel.For(0, agentPlanes.Length, i =>
136
        {
137
            // update at max Force
138
            agentPlanes[i].UpdateDirectionAndPosition();
139

140
        });
141
    }
142
}