The Seashell’s Anatomy – A Story of adaptation, innovation, and survival

Tools: Rhinoceros, Grasshopper, C#

Natural forms in the world around us often emerge as a result of growth and adaptation, a crucial aspect of survival.  Seashells serve as striking examples of how living organisms evolve to create unique and functional shapes by carefully balancing the proportions of their dwellings.

CALCIUM CARBONATE, SPECIALISED CELLS, AND ORGANIC MATRIX

Seashell growth is a complex process that involves both biology and chemistry. Seashells are mostly made of a substance called calcium carbonate (CaCO₃), which is common in the oceans. To understand how seashells grow, we need to know how marine creatures take calcium and carbonate from the water and use them to build their shells.

Picture the oceans as vast reservoirs of minerals dissolved in water. Naturally, the oceans contain a substantial amount of calcium ions (Ca²⁺), originating from the breakdown of rocks and minerals. These dissolved calcium ions serve as fundamental building blocks for marine organisms engaged in biomineralization, which is their ability to extract calcium and carbonate ions (CO₃^2-) from their surroundings and fuse them into solid calcium carbonate crystals.

Marine organisms responsible for shell formation possess specialised cells, often referred to as “calcifying cells” or “shell-forming cells.” These cells oversee the uptake, transportation, and deposition of calcium ions.

In addition to calcifying cells, organisms secrete an organic matrix comprising proteins, lipids, and other biomolecules that act as templates. This matrix guides the precise arrangement of calcium carbonate crystals. A shell typically encompasses a mantle region, which may extend beyond the shell itself. In this area, extra-pallial fluid is secreted, containing components required for the “construction” process.

Ocean Acidification: The ocean absorbs approximately 30% of atmospheric carbon dioxide (CO2), leading to chemical reactions that raise hydrogen ion concentration, resulting in ocean acidification and reduced carbonate ions, making it challenging for calcifying organisms to build and maintain their calcium carbonate structures.

GROWING STRUCTURES

The spiral form of seashells is a testament to the mathematical precision that enables the shell to continue growing while accommodating the developing mollusk. The part of the shell where the creature resides, responsible for adding new material, is located at the open edge. It deposits more material on one side than the other, resulting in the shell’s spiral shape. The specific rates at which shell material is added at different points along the open edge are determined by the animal’s anatomy, and changing these rates can yield a wide range of shapes.

There are essentially three rates of growth:

1. The rate at which the aperture moves away from the coil’s axis.
2. The rate of translation, determining how far the shell coils along the z-axis.
3. The rate at which the aperture increases in size.

From a geometric perspective, the shell’s outer surface can be described as a three-dimensional structure formed by a curve, typically an ellipse known as the generating curve (generatrix), moving along a helical spiral called the structural curve (directrix). As the generating curve travels along the helical path, it gradually widens, giving rise to the shape of the shell.

To build it in Grasshopper, I used the model described in JORGE PICADO’s paper [1], which gives more details on the mathematics of seashell forms.

The path (directrix)

The spiral pattern in shells is often referred to as a logarithmic or equiangular spiral. This type of spiral has a distinct mathematical property: for every constant rotation angle (for example one full revolution), the distance from the spiral’s origin (the pole) is multiplied by a fixed factor. This means that as you move along the spiral, the angle between the direction you’re looking and the direction you’re moving remains the same. This consistent angle gives shells their harmonious appearance, as each segment of the spiral is proportionally similar to the next. 

This spiral can be described with 3 parameters  :

• alpha (equiangular angle) – impacts how the aperture moves away from the axis (90° is a circle)
• beta (enlarging angle) – impacts the translation rate (0 will result in vertical line 90 in flat spiral)
• A – the aperture size

Creating a curve involves the process of interpolating points that meet the given equations:

x(θ) = A sin β cos θ e^θcotα 
y(θ) = A sin β sin θ e^θcotα 
z(θ) = −A cos β e^θcotα 

Where θ represents the rotation angle, α and β are equiangular and enlarging angles respectively. The e^θcotα  is the increasing rate for θ >0.

Logarithmic spirals can be observed in nature highlighting their significance in optimising growth, distribution, and other natural processes. A special case of the logarithmic spiral with the growth rate of Phi (φ) results in a “Golden Ratio” spiral with the unique properties. Take a look at my post on this topic to discover more about spiral patterns in plants.

To make the spiral coil counter clockwise change the sign of the X equation. I will use the parameter D that takes the value of 1 or -1 to set the coiling direction.

private void RunScript(int D, int N, double alpha, double beta, double A, ref object Pts, ref object Dir)
  {
    List<Point3d> spiralPoints = ComputePoints(alpha, beta, A, N, D);
    Curve directrix = Curve.CreateInterpolatedCurve(spiralPoints, 3);
    Pts = spiralPoints;
    Dir = directrix;
  }
  public List<Point3d> ComputePoints (double alpha, double beta, double A, int N, int D)
  {
    List<Point3d> spiralPoints = new List<Point3d>();
    for (double theta = 0.00; theta < N; theta += 1){
      double X = D * A * Math.Sin(beta) * Math.Cos(theta) * Math.Exp(theta * (Math.Cos(alpha) / Math.Sin(alpha)));
      double Y = A * Math.Sin(beta) * Math.Sin(theta) * Math.Exp(theta * (Math.Cos(alpha) / Math.Sin(alpha)));
      double Z = -A * Math.Cos(beta) * Math.Exp(theta * (Math.Cos(alpha) / Math.Sin(alpha)));
      Point3d currentPt = new Point3d(X, Y, Z);
      spiralPoints.Add(currentPt);
    }
    return spiralPoints;
  }

Most  snails  have right-coiled shells. However, there are some rare snail species with left-coiled shells, like Jeremy. These snails are known as “sinistral” snails. They are typically encountered less frequently than their right-coiled counterparts. That makes it hard for them to mate as it is not easy to find other left-coiled snails.

The section (generatrix)

The section of the curve that forms the shell can be simplified to an ellipse. With two parameters :

• a – semi-minor axis
• b – semi-major axis

To keep it simple, I used the RhinoCommon Ellipse constructor, which creates an ellipse with a base plane and both principal radii (a, b), instead of using the ellipse equation from the paper.

To create the base planes, we can use the base points obtained in the first step. In order to construct the plane frames, we need to define an origin (base point) and two vectors for the local xy axis. Our goal is to have the frames follow the path while remaining in a “vertical” position.

To achieve this, the y-axis of each plane aligns with the global Z-axis. This means that the x-axis of each frame should be perpendicular to both the y-axis and the direction of the path. To determine this x-axis, we calculate a cross product between the global Z-axis and a normal vector to the curve N(C) at each base point.

The model easily handles scenarios where the generating ellipse rotates in three-dimensional space. This is achieved by using three angles, ϕ, ω , and μ. These angles describe the rotations around particular axes:

• ϕ corresponds to the rotation around a vector perpendicular to the plane of the ellipse.
• ω corresponds to the rotation around the Z (vertical) axis.
• μ corresponds to the rotation around the horizontal axis of the ellipse.

private void RunScript(int D, int N, double alpha, double beta, double A, double a, double b, double phi, double mu, double omega, ref object Pts, ref object Dir, ref object Frames, ref object Gen)
  {
    List<Point3d> spiralPoints = ComputePoints(alpha, beta, A, N, D);
    Curve directrix = Curve.CreateInterpolatedCurve(spiralPoints, 3);

    List<Vector3d> tangentVts = new List<Vector3d>();
    List<Point3d> basePts = new List<Point3d>();
    List<double> frameTs = ComputeTs(directrix, out basePts, out tangentVts);
    List<Plane> frames = ComputeFrames(basePts, tangentVts);
    List<Plane> rotatedFrames = RotateFrames(frames, phi, mu, omega, D);

    List<Ellipse> generatrixCurves = CreateGeneratrixCurves(rotatedFrames, a, b, alpha);

    Pts = spiralPoints;
    Dir = directrix;
    Frames = rotatedFrames;
    Gen = generatrixCurves;
  }

  public List<Point3d> ComputePoints (double alpha, double beta, double A, int N, int D)
  {
    List<Point3d> spiralPoints = new List<Point3d>();
    for (double theta = 0.00; theta < N; theta += 1){
      double X = D * A * Math.Sin(beta) * Math.Cos(theta) * Math.Exp(theta * (Math.Cos(alpha) / Math.Sin(alpha)));
      double Y = A * Math.Sin(beta) * Math.Sin(theta) * Math.Exp(theta * (Math.Cos(alpha) / Math.Sin(alpha)));
      double Z = -A * Math.Cos(beta) * Math.Exp(theta * (Math.Cos(alpha) / Math.Sin(alpha)));
      Point3d currentPt = new Point3d(X, Y, Z);
      spiralPoints.Add(currentPt);
    }
    return spiralPoints;
  }

  public List<double> ComputeTs (Curve curve, out List<Point3d> basePts, out List<Vector3d> tangentVts){
    basePts = new List<Point3d>();
    tangentVts = new List<Vector3d>();
    List<double> ts = new List<double>();
    for (double i = 0.00 ; i < curve.SpanCount; i += 1){
      ts.Add(i);
      basePts.Add(curve.PointAt(i));
      tangentVts.Add(curve.TangentAt(i));
    }
    return ts;
  }

  public List<Plane> ComputeFrames (List<Point3d> basePts, List<Vector3d> tangentVts) {
    List<Plane> frames = new List<Plane>();
    for (int i = 0; i < basePts.Count; i++) {
      Vector3d crossProduct = Vector3d.CrossProduct(tangentVts[i], Vector3d.ZAxis);
      Plane frame = new Plane(basePts[i], crossProduct, Vector3d.ZAxis);
      frames.Add(frame);
    }
    return frames;
  }

  public List<Plane> RotateFrames (List<Plane>frames, double phi, double mu, double omega, int D){
    List<Plane> rotatedFrames = new List<Plane>();
    foreach (Plane frame in frames) {
      Transform rotationPhi = Transform.Rotation(D * phi, frame.ZAxis, frame.Origin);
      frame.Transform(rotationPhi);
      Transform rotationMu = Transform.Rotation(mu, frame.XAxis, frame.Origin);
      frame.Transform(rotationMu);
      Transform rotationOmega = Transform.Rotation(omega, frame.YAxis, frame.Origin);
      frame.Transform(rotationOmega);
      rotatedFrames.Add(frame);
    }
    return rotatedFrames;
  }

  public List<Ellipse> CreateGeneratrixCurves (List<Plane> frames, double SecW, double SecH, double alpha){
    List<Ellipse> generatrixCurves = new List<Ellipse>();
    for (int i = 0; i < frames.Count; i++){
      Ellipse generatrixCrv = new Ellipse(frames[i], Math.Exp(i * Math.Cos(alpha) / Math.Sin(alpha)) * SecW, Math.Exp(i * Math.Cos(alpha) / Math.Sin(alpha)) * SecH);
      generatrixCurves.Add(generatrixCrv);
    }
    return generatrixCurves;
  }

This simplified model doesn’t consider spikes and tendrils. Despite this simplification, it can still produce quite accurate replica for some species :

The next step will be to build a detailed model that accommodates noodles and spikes.

To be continued…

Resources:

1. Picado, Jorge. ‘Seashells: The Plainness and Beauty of Their Mathematical Description’. Washington, DC: The MAA Mathematical Sciences Digital Library, 25 March 2009. https://doi.org/10.4169/loci003294.
2. Cortie, M.B. ‘Digital Seashells’. Computers & Graphics 17, no. 1 (January 1993): 79–84. https://doi.org/10.1016/0097-8493(93)90054-D.