## Description

Elliptic coordinates are similar to polar coordinates, but use confocal (nested) ellipses instead of circles and hyperbolae instead of lines (lines would not be perpendicular to the ellipses as they are to circles). The point (μ, ν) is μ units from the vertex of the hyperbola associated with angle ν, which is normally specified in radians. (The symbols μ and ν are the greek letters mu and nu.) Here is a diagram that shows how it works:

**Name:** elliptic**Type:** 2D**Author:** Joel and Michael Faber

**Name:** eMotion**Type:** 2D**Author:** Michael Faber

**Name:** ePush**Type:** 2D**Author:** Michael Faber

**Name:** eRotate**Type:** 2D**Author:** Michael Faber

**Name:** eScale**Type:** 2D**Author:** Michael Faber

Normally μ is nonnegative and ν is between -π and π. (In most uses of elliptic coordinates, ν is between 0 and 2π, but here we follow the usage of the flame variations that use them.) Other values can still be logically associated with points, but it is non-standard and associates multiple coordinates with each point; for example (-1, 3π/2) is the same point as (1, π/2).

A rectangular tiling has tiles arranged in rows and columns. In contrast, an elliptic tiling arranges the tiles in ellipses and hyperbolae, as shown below. In this image, the ellipses are readily apparent, but the hyperbolae are harder to see. Start with the vertical line of disks which is a degenerate hyperbola: a vertical line. To either side of it is a line of disks that form a gentle curve and next to each is a line of disks that form a sharper curve. Finally, in the center of each of these is another degenerate hyperbola: a line starting at the small disk and proceeding outward.

This tiling was made in JWildfire in much the same way as a rectangular tiling, but using the eMotion variation instead of linear. EMotion has two parameters that specify how much to move the point along the elliptic coordinates: the value of move is added to μ (moving the point along the hyperbola) and the value of rotate is added to ν (moving the point around the ellipse). The above tiling uses four transforms with eMotion: one with move=0.5 and rotate=0, one with move=-0.5 and rotate=0, one with move=0 and rotate=π/6, and one with move=0 and rotate=-π/6.

We note in passing the variation eRotate, which does only rotation. It is the same as eMotion with move=0, so doesn’t add any new capability. We’ll use only the more flexible eMotion here.

Elliptic tilings are not as useful as rectangular tilings because the tiles need to be a strange shape to fit exactly. Using normal variations will result in either spaces between the tiles or overlaps. But accepting this, we can still get interesting flames by replacing the blur with a more interesting transform (and using a better gradient). Here we replace it with ngon and add a final coth.

Just as we can find interesting flames using only a few transforms with linear, with the pre-affine transforms moving points along rectangular coordinates, we can find very different flames using only a few transforms with eMotion, using the eMotion parameters to move points along elliptic coordinates. There is one catch: we still need to scale down the pre-affine transforms to make it work. Here is an example of the technique using two transforms, both scaled down by 135%. The variation on both transforms was changed to eMotion, and the move and rotate parameters were changed to find something interesting.

The affine transforms were deliberately only scaled, not moved or rotated, so only elliptic coordinate moves were used. But we have no particular reason to be purists! Combining rectangular and elliptic motion can create many different flames. Keep in mind that changes to pre-affine and post-affine transforms have different effects. Here is an example.

The eScale variation scales the elliptic coordinates of a point by multiplying μ and ν by the scale parameter. It’s effect is shown in the image below, applied to a dc_perlin pattern. When scale is 1, eScale has no effect as shown in the center example. The left example has scale set to 0.75, which is less than 1 so decreases μ and ν. Decreasing μ moves the points closer to the elliptical foci, shrinking the pattern. Decreasing ν rotates the points of the pattern towards the right side, sort of like closing a folding hand fan. It has a larger effect on the left side, where ν is the largest. The right example has scale set to 1.25, so does the opposite. Increasing μ expands the pattern and increasing ν rotates the points in the opposite direction, causing an overlap.

A second parameter, angle, specifies the angle to use when scaling ν. The default is 0, used in the examples above. Changing it to π/2≈1.5708 (that’s 90 degrees converted to radians) results in the examples below. Notice how the greatest effect is opposite the angle. Due to the way eScale is implemented, negative angles should not be used; instead add 2π to make it positive. For example, use 3π/2 rather than -π/2.

The eScale and eMotion variations both use elliptic coordinates and work well together. Here is a base flame with two transforms, one with eScale using scale=0.5 and angle=1.5708≈π/2 (90°), and the other with eMotion using move=0.5 and rotate=0.7854≈π/4 (45°). We want eMotion to be iterated a lot more often than eScale, so its weight is set to 5. See the Flame pack below under Resources for the parameters.

Although this is only mildly interesting, moving and rotating the triangles for the two transforms can create nice flames. Here are some examples. Don’t forget to tweak both the pre and post transforms, and try tweaking the eScale and eRotate parameters as well.

The ePush variation is similar to eMotion. Indeed, the rotate parameter works exactly the same (the value is added to ν, causing a rotation). The value of the push parameter is added to μ like the eMotion move parameter, but it works differently. With eMotion, positive values move the point up and negative values move it down. With ePush, positive values move the point away from the center (creating a hole) and negative values move it towards the center (creating overlap). We illustrate this with the same dc_perlin pattern we used earlier for eScale. The middle example has push set to 0 (so no change), the left one has push set to -0.25 (notice the overlap), and the right one has push set to 0.25 (notice the hole).

The hole created by ePush with a positive push value invites us to fill it. We can use any variation that results in a circle, such as bubble, eyefish, or the disc variations; we turn the circle to an ellipse by skewing the post-affine transform. Here is a starting point using ePush and idisc. To make it more interesting, the post-affine transform for both transforms is rotated 90°. Then the idisc circle was made to fit in the ePush hole by adjusting the X2 and Y1 values independently.

This can be tweaked in lots of ways, but keep two things in mind. First, the post-affine rotation angle of the two transforms needs to match to keep the ellipse inside the hole. Rotating them does give interesting results, so do try that; just be sure to do the same thing to both transforms. (The pre-affine transforms can be rotated independently.) Second, if the push parameter is changed, the post-affine scaling of the other transform will need to be adjusted to make the ellipse fit into the new hole. This is easiest when the post-affine rotation angles is 0° or 90°, so if you have changed it you may want to temporarily change it back to adjust the size.

As an example of these two requirements, the following image was created by starting with the one above, increasing the push parameter to 0.65, adjusting the idisc post-affine scaling to make it fit, then rotating both post-affine transforms 45° clockwise.

The ePush variation has another parameter, dist, which scales μ only, making the result larger or smaller when dist is greater or less than 1. It does not change the size of the hole created by a positive value for push.

Finally, the elliptic variation takes the elliptic coordinates (μ, ν) of a point and treats them as rectangular coordinates, with x=ν/π and y=±μ/π, much as the polar and bipolar variations do for polar and bipolar coordinates. At least that’s the idea; the implementation isn’t precise, though it still produces interesting results. To see what it does, we take the elliptic tiling from above and add a final elliptic to get a (slightly imperfect) rectangular tiling:

Elliptic combines beautifully with splits to produce the popular splits-elliptic style. This is a foundational flame style, which all flame fractalists should be familiar with. Several tutorials are listed below in the Resources section, and they are all slightly different from each other. Since this is such an important style, it is worthwhile to go through all of these tutorials, noting the differences and how the result is affected. We proceed with yet another splits-elliptic interpretation.

Basically, the splits variation with parameter x set to 1 and the rest 0 will take the flame and split it in the middle, shifting half left and half right to leave a gap of width 1 in the middle. We use elliptic with an amount of 1 to fill it in (values besides 1 will work as long as splits x and the elliptic amount match). We also add 90° post-affine rotations to both transforms to make the result more interesting.

Start with a new flame, and on the Camera tab change Zoom to 4. Add a transform, and set the weight to 1. Change the variation to splits and set parameter x to 1 and the others to 0. In the Affine tab, with Post TF off, enlarge the triangle by 200%, then turn Post TF on and rotate left 90°. Add a second transform and change the variation to elliptic. In the Affine tab, with Post TF off, rotate left 90° and shrink the triangle by 200%, then turn Post TF and rotate left 90°. In the Color tab, set the Color to 1. Select a gradient and adjust the coloring to get a starting point something like this.

This can be tweaked in many ways; that’s one reason this style is so popular. One interesting tweak is to add a second elliptic to make a splits-double-elliptic flame. First, set the splits y parameter to 0.5, then add a new transform, change the variation to elliptic and the amount from 1 to 0.5, then rotate the pre-affine triangle left 90°. Don’t change the post-affine transform. To bring out the details, change the splits weight to 3. Here is the result:

Of course, other tweaks are needed to make a compelling flame. For the following, a tiny amount of ho was added to the second elliptic to create a different pattern, and a final foci was used to reshape the result.

We conclude by mentioning several variations closely related to the ones we’ve explored without going into a lot of detail.

Name: elliptic2

Author: Brad Stefanov

A version of elliptic with parameters added to change its output. The default values make it work the same as elliptic, so use elliptic2 in place of elliptic and tweak the parameters to see what happens.

Name: spliptic_bs

Author: Brad Stefanov

A mix of splits and elliptic. Despite the name, it doesn’t create a splits-elliptic style flame by itself. It is useful for nesting two elliptics in a splits flame (in contrast to the splits-double-elliptic described above, which uses two independent elliptics). Here is an example; see the flame pack for the parameters.

Name: acosh

Author: Whittaker Courtney

Returns the inverse hyperbolic cosine of the input point (x,y) taken as a complex number x+yi. This happens to be the mathematical operation that converts rectangular to elliptic coordinates, so acosh is similar to elliptic, except that it swaps x and y, and doubles the output.

Name: cosh

Author: Gregory Zitelli

Returns the hyperbolic cosine of the input point (x,y) taken as a complex number x+yi, which is the mathematical operation that converts elliptic to rectangular coordinates. So cosh basically take the rectangular coordinates of a point and treats them as elliptic coordinates. This is what unpolar and foci do with log-polar and bipolar coordinates respectively (see Unpolar and Foci), and can be used in the same way as those variations.

## Parameters

variation amount | Scale factor for the result |

angle | The base angle for scaling ν, in radians. The default is 0. Scaling moves points toward the base angle, so the largest effect will be seen opposite the angle. It should be non-negative. |

dist | The scale factor for μ. The default is 1 (no scaling). Values larger than 1 move points outward, and values between 0 and 1 move points inward. Negative values are allowed, and reflect the points across the x axis. |

move | The distance to move points along the hyperbolae of the elliptic coordinate system. The default is 0 (no movement). Positive values move points up and negative values move them down. |

push | The distance to move points along the hyperbolae of the elliptic coordinate system. The default is 0 (no movement). Positive values move points away from the center, leaving an elliptic hole. Negative values move points the opposite direction, causing overlap. |

rotate | The amount to rotate points along the ellipses of the elliptic coordinate system, in radians. The default is 0 (no movement). |

scale | The scale factor for both μ and ν. The default is 1 (no scaling). Scaling μ works the same as dist; see above. Scaling ν rotates points towards the base angle specified by the angle parameter. Values greater than 1 increase the angle, causing overlap. Values between 0 and 1 decrease the angle, creating a space opposite the base angle. |

## Resources

Flame pack (flames used above)

Elliptic Coordinate System at Wikipedia

Splits-Elliptic Tutorial by SaTaNiA (Damien Girodon)

JWildfire Elliptic-Splits Tutorial by Naomi Richmond (adaptation of above tutorial)

Smo Elliptic Splits by Epogh (JJ Viviers)

Apophysis Base Forms Pack by TyrantWave (Chris Johns), includes a splits-elliptic base flame

Common Frameworks 2: Elliptic Splits by tatasz (Tatyana Zabanova) for Chaotica

Blurry Elliptic Splits by tatasz (Tatyana Zabanova) for Chaotica