(Edited on 2022/12/11 to correct typos)

In a recent video, Numberphile has interviewed Val Narushin, a researcher who has co-authored a paper about the mathematical shape of eggs. The formula he has designed has the interesting property of being able to modelise all four types of egg with only four parameters. The formula is complicate, but not difficult to implement, so I've jumped on the occasion to make a POV-Ray script based on it to generate nice looking eggs.

There was two difficulties to create that script: define how to randomly select the value of the four parameters of Narushin's formula, and define how to randomly create the texture.

The four parameters are: the length of the egg \(L\), its maximum radius \(B\), the deviation of the maximum radius from the center \(w\), and the radius at a quarter length from the tip of the small end \(D\). The length and maximum radius are easy to understand, so I've decided to use them as the input of the main macro. The two others are much less intuitive, so I decided to calculate them automatically based on the two first ones.

To control more easily the two other parameters, I'm using the ratio of the maximum radius to the length, \(r\), and I arbitrarily impose that \(r=0.5\) means the egg as a perfect spherical shape. The smaller \(r\) becomes the more "triangular" the shape becomes.

The deviation of the maximum radius from the center can theoritically go from 0 to half the length, but the nearer from half the length it gets the less realistic the shape becomes. This is illustrated in figure 4 of Narushin's paper. Then I'm using \(r\) to control it and keep the shape realistic, as follow: \(w=L/8*rand()*(1-r)\). A perfectly spherical egg gives \(w=0\), as expected, and less spherical eggs allow for more deviation, up to \(w=\frac{2L-B}{15L}\).

The value of \(D\) should always be less than those of \(B\), and such as it produces a perfect sphere when \(r=0.5\). It's easy to calculate that for the perfect sphere \(D=sin(cos^{-1}(0.5))B\approx 0.866025B\). Then I choose to calculate \(D\) as follow: \(D=B*0.866025*(a+r*(1-a))\) where \(a=.75+.25*rand()\).

About the texture, I've simply referred to pictures of bird eggs on the Internet and freely created one that look similar with a multiple layer approach. The first layer is the base color of the egg: one randomly chosen color biased toward light tone as bird eggs seem to be so, with subtil variations to avoid an unnatural uniformity. On top of that first layer, a random number of layers provide the stains usually seen on eggs. Each layer as a random stain color and stain size. I addition, I set the values for finish phong and normal bump randomly within ranges that render similar to the pictures I've referred to.

Finally I've split the macro into sub-macros such as it's possible to create the shape with given parameters or random parameters, with or without a random texture.

The result looks like the image below (click to enlarge):

The include file containing the macros (also available to download here):

/* egg.inc - macros implementing Narushin's egg function Copyright (C) 2022 Pascal Baillehache baillehache.pascal@gmail.com https://baillehachepascal.dev This script is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This script is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. */ // Top level macro creating an egg with given length and maximum // radius, and random shape and texture // Inputs: // lengthEgg: length of the egg from the tip of the large end to the // tip of the small end // radiusEgg: radius of the egg (from the rotation axis passing // through the tips) at its largest position // seedShape: seed for the PRNG used to create the shape // seedTexture: seed for the PRNG used to create the texture // The tip of the big end is located at <0,0,0>. The tip of both ends // lie on the y axis. #macro EggRndShapeRndTexture(lengthEgg, radiusEgg, seedShape, seedTexture) object { EggRndShape(lengthEgg, radiusEgg, seedShape) EggRndTexture(lengthEgg, radiusEgg, seedTexture) } #end // Macro creating an egg with given length and maximum radius, and // random shape // Inputs: // lengthEgg: length of the egg from the tip of the large end to the // tip of the small end // radiusEgg: radius of the egg (from the rotation axis passing // through the tips) at its largest position // seedShape: seed for the PRNG used to create the shape // The tip of the big end is located at <0,0,0>. The tip of both ends // lie on the y axis. #macro EggRndShape(lengthEgg, radiusEgg, seedShape) // Create PRNG for the shape #local rndSeedShape = seed(seedShape); // Calculate the parameters 'w' and 'D' of Narushin's fornmula. // Randomly chosen in a way to keep them realistic according to // the ratio radius/length. If it's equal to 1.0, it will produce a // spheric egg, else it will produce one of the three other types. #local t_ = radiusEgg / lengthEgg; #local w = lengthEgg / 8 * rand(rndSeedShape) * (1- t_); #local r = .75 + .25 * rand(rndSeedShape); #local D = radiusEgg * 2 * 0.866025 * (r + t_ * (1 - r)); // Create the egg given the four parameters EggShape(lengthEgg, radiusEgg * 2, w, D) #end // Macro creating an egg given the four parameters of Narushin's formula // Inputs: // L: length from tip of big end to tip of small end // B: maximum breadth // w: distance from half length to position of the maximum breadth // D: breadth at L/4 from tip of small end // The tip of the big end is located at <0,0,0>. The tip of both ends // lie on the y axis. #macro EggShape(L, B, w, D) // Uses a lathe with cubic_spline to create the egg as a surface of // revolution lathe { cubic_spline // Number of points on the lathe #local nbPoint = 100; // Uses two extra points for the cubic interpolation at the // extremities. (nbPoint+2), // The first extra point is the mirrored point of the second point. #local x_ = (1 / (nbPoint - 1) - .5) * L; <-1 * Narushin(x_), x_> // Loop on the points along the egg surface #local iPoint = 0; #while (iPoint < nbPoint) #local x_ = (iPoint / (nbPoint - 1) - .5) * L; <Narushin(x_), x_> #local iPoint = iPoint + 1; #end // The second extra point is the mirrored point of the penultieme // point. #local x_ = ((nbPoint - 2) / (nbPoint - 1) - .5) * L; <-1 * Narushin(x_), x_> // Translate the shape to position the tip of the big end at <0,0,0> translate L / 2 * y } #end // Narushin's formula #macro Narushin(x_) #local y1 = B/2*sqrt((L*L-4*x_*x_)/(L*L+8*w*x_+4*w*w)); #local y2 = sqrt(5.5*L*L+11*L*w+4*w*w)*(sqrt(3)*B*L-2*D*sqrt(L*L+2*w*L+4*w*w))/(sqrt(3)*B*L*(sqrt(5.5*L*L+11*L*w+4*w*w)-2*sqrt(L*L+2*w*L+4*w*w))); #local y3 = sqrt(L*(L*L+8*w*x_+4*w*w)/(2*(L-2*w)*x_*x_+(L*L+8*L*w-4*w*w)*x_+2*L*w*w+L*L*w+L*L*L)); #local y_ = y1 * (1 - y2 * (1 - y3)); y_ #end // Macro creating the random texture of an egg with given length and // maximum radius // Inputs: // lengthEgg: length of the egg from the tip of the large end to the // tip of the small end // radiusEgg: radius of the egg (from the rotation axis passing // through the tips) at its largest position // seedTexture: seed for the PRNG used to create the texture #macro EggRndTexture(lengthEgg, radiusEgg, seedTexture) // Create the PRNG for the texture #local rndSeedTexture = seed(seedTexture); material { // Main texture texture { // Main color, biased toward light tone #local r = 1 - pow(rand(rndSeedTexture), 2); #local g = 1 - pow(rand(rndSeedTexture), 2); #local b = 1 - pow(rand(rndSeedTexture), 2); // Variables to create a non uniform texture #local rd = .05 * rand(rndSeedTexture); #local gd = .05 * rand(rndSeedTexture); #local bd = .05 * rand(rndSeedTexture); pigment { // Uses a bozo pigment map with small deviation from the main // color to avoid a boring uniform texture bozo pigment_map { [0.0 color rgb <r-rd,g-gd,b-bd>] [0.5 color rgb <r,g,b>] [1.0 color rgb <r+rd,g+gd,b+bd>] } scale radiusEgg * 2 * rand(rndSeedTexture) } // Random normal bump #local bs = .05 + .25 * rand(rndSeedTexture); normal { bumps bs scale 0.5 * radiusEgg } // Random finish #local p = .1 + .3 * rand(rndSeedTexture); #local ps = 5 + 50 * rand(rndSeedTexture); finish { phong p phong_size ps} // Random translate to avoid uniformity translate rand(rndSeedTexture) * 10 } // Add a random number of layered textures to create the stains #local iLayer = 0; #local nbLayer = 0; #while (iLayer < 3) // Randomise the existence of the layer at each level #if (rand(rndSeedTexture) < 0.33) texture { pigment { // Uses another bozo pigment map with parameters depending // on the layer level bozo #local map2 = .8 + .15 * rand(rndSeedTexture) - iLayer * .05; #local map1 = map2 - .4 * rand(rndSeedTexture) - iLayer * .05; #local r = rand(rndSeedTexture); #local g = rand(rndSeedTexture); #local b = rand(rndSeedTexture); color_map { [0.0 color rgbt <1, 1, 1, 1> ] [map1 color rgbt <1, 1, 1, 1> ] [map2 color rgbt <r,g,b,0> ] [1.0 color rgbt <r,g,b,0> ] } // Warp and random rotate to avoid uniformity warp { turbulence .5 } rotate <rand(rndSeedTexture), rand(rndSeedTexture), rand(rndSeedTexture)> * 360 } // Parameterise also the size of the stains based on the layer // level scale radiusEgg * (1 + iLayer / 3) } #end #local iLayer = iLayer + 1; #end scale <radiusEgg, lengthEgg, radiusEgg> } #end

The file main.pov to render the example image above.

#version 3.8; // Include the macros implementing Narushin's egg formula #include "egg.inc" // Global settings #include "rad_def.inc" global_settings { radiosity { Rad_Settings(Radiosity_Normal,off,off) error_bound 2.0 count 300 } assumed_gamma 1.0 } #default { finish { ambient 0 } } background { color rgb 12/15 } // Camera, orthographic to keep the shape undeformed and make it more // readable camera { orthographic right x up y * 3/4 location -z look_at 0 } // light source light_source { <-.6,.5,-3> color rgb .4 area_light x*.8, y*.8, 10 ,10 jitter orient } // Neutral grey background on which the eggs will be aligned plane { z, 0 pigment { color rgb 12/15 } } // Align several eggs in a 2D matrix on the plane with random parameters #declare lengthEgg = 0.1; #declare rndSeed = seed(1); #declare scaleMin = 0.5; #declare scaleMax = 1.0; #declare iCol = 0; #declare nbCol = 9; #while (iCol < nbCol) #declare iRow = 0; #declare nbRow = 7; #while (iRow < nbRow) // Seed for the macro creating the egg shape, chosen arbitrarily #declare seedShape = iRow * nbCol + iCol + 700; // Seed for the texture creating the egg texture, chosen arbitrarily #declare seedTexture = seedShape; // Random radius for the egg, from equal to the egg length (spheric // egg) to half the length #declare radiusEgg = lengthEgg / 2 * (.5 + rand(rndSeed) * .5); // Egg object object { // Call the macro to create the egg EggRndShapeRndTexture(lengthEgg, radiusEgg, seedShape, seedTexture) // Scale the egg for nice looking variety #local scale_ = rand(rndSeed) * .5 + .5; scale scale_ // Position the egg on the plane translate <iCol - (nbCol - 1) / 2, iRow - (nbRow - 1) / 2 - 0.5, 0> * lengthEgg translate radiusEgg * scale_ * -z // Add some perturbation to avoid perfect alignment translate <(rand(rndSeed)-.5)*.1,(rand(rndSeed)-.5)*.1,0.0> * lengthEgg } #declare iRow = iRow + 1; #end #declare iCol = iCol + 1; #end

The main.ini file to render the example image above:

Output_to_File=on Input_File_Name=main.pov Output_File_Name=egg.png Antialias=on Display=off Width=1200 Height=900 File_Gamma=1.0 Display_Gamma=1.0

The command to render the example image: povray main.ini.

Finally, note that POV-Ray also provides an ovus shape to render egg-like shape. Cf here.