The equation for the Mandel Box looks like this:

  Z = BallFold( BoxFold(Z) ) * S + C  

    C = The 2D or 3D point that is being tested.
    S = Floating point scaling value.
    Z = A 2D/3D point that is initially set to zero.
    BoxFold = A square folding function.
    BallFold = A spherical folding function.

As before, the formula is iterated and tested to see if the Z-distance starts moving towards infinity.
 

Folding. The key to the Mandel Box is a series of folding operations where the points are folded back on themselves in various ways.

 Box Folds. The Box Folds fold the points back on themselves along straight lines. To create the fold, we check to see if a point is beyond the Fold Point and if it is, we fold it back by subtracting. For example, here is the code to do this for the X-Axis:

if X > 1 then X := 2 - X

The diagram to the right illustrates the process. If the X-value of a point were at 1.4, it would be folded back until it is repositioned at 0.6.

The animation to the right shows the folding operation on a 2D grid. You can see the grid being folded along the 1 and -1 lines for both the X and Y axis. (In the actual operation, the fold is carried out all at once, so you don't see the fold go through 180 degrees of rotation.

Here is sample code that performs the Box Fold:

procedure BoxFold(var Pnt: T3DVector);
begin
if Pnt.x > 1 then Pnt.x := 2 - Pnt.x
else if Pnt.x < -1 then Pnt.x := -2 - Pnt.x;

if Pnt.y > 1 then Pnt.y := 2 - Pnt.y
else if Pnt.y < -1 then Pnt.y := -2 - Pnt.y;

if Pnt.z > 1 then Pnt.z := 2 - Pnt.z
else if Pnt.z < -1 then Pnt.z := -2 - Pnt.z;
end;
										

To accomplish the fold, all points inside the Min Radius are stretched so the inner radius is expanded out to 2. This is accomplished by multiplying each point inside the radius by 4. To see how the stretching is accomplished, here are examples of different radii multiplied by 4:

const FixedRadius = 1.0;
const MinRadius = 0.5;
const RadiusRatio = sqr(FixedRadius) / sqr(MinRadius);


procedure BallFold(var Pnt: T3DVector);
var Radius,RF: double;
begin
Radius := sqrt(Sqr(Pnt.X) + Sqr(Pnt.Y) + Sqr(Pnt.Z));
if Radius < MinRadius then
	begin
	Pnt.X := Pnt.X * RadiusRatio;
	Pnt.Y := Pnt.Y * RadiusRatio;
	Pnt.Z := Pnt.Z * RadiusRatio;
	end
else if Radius < FixedRadius then
	begin
	RF := Sqr(FixedRadius) / Sqr(Radius);
	Pnt.X := Pnt.X * RF;
	Pnt.Y := Pnt.Y * RF;
	Pnt.Z := Pnt.Z * RF;
	end
end;								

The code above shows the Ball Fold operation. The code transforms one point, folding it as necessary. First, the distance from the origin is calculated, which gives you a Radius. If the radius is less than Minimum Radius, the point is multiplied by a constant, effectively stretching all points inside the inner circle. If the point is between Minimum Radius and Fixed Radius, the point is multiplied by a variable value that decreases as the radius approaches the Fixed Radius.

This effectively folds the points over the Fixed radius. Most people use constant values for the Fixed Radius and Minimum Radius of 1.0 and 0.5 respectively. Using those values, you can simplify the code a bit. RadioRatio becomes 4 and RF becomes 1/Radius^2.

Scaling. The third step in the process is scaling. Each component of a point is multiplied by a scale factor. If the scale factor is greater than one, all the points are expanded away from the center. If the scale value is less than one, all the points contract toward the center.  Negative factors flips the points from positive to negative or negative to positive. The animation to the right illustrates the scaling process.

The animations show the folding and scaling in a smooth, continuous operation to visually illustrate the process. For example, the animations show the software slowly bending the points until the fold is completed. The actual folding and scaling process is carried out all at once.

Escape. The folding and scaling operations are repeated for an individual point until it is clear whether the point is a part of the set. This determined by whether the point moves beyond a certain limit after several iterations.

The code to the right shows the process. After the Box Fold, Ball Fold and Scaling are done, the result is added to the test point C. Next, the magnitude of the new point is calculated. This will be the distance from the origin to the point. If the distance exceeds the Escape value, the point is outside the set. If the point makes it through all iterations without its distance exceeding the Escape value, the point is inside the set.

The full code for processing one point in the Mandel Box set is available here. 

var Escape: integer = 4;
var Iterations: integer = 16;

Point:=MakePoint(0,0,0);
Inside:=False;
for Iter:=0 to Iterations-1 do
	begin
	BoxFold(Point);
	BallFold(Point);
	Scale(Point);
	Point:= VectorAdd(Point,C);
	Len := Magnitude(Point);
	if Len > Escape then exit;
	end;
Inside:=True;

The images to the right show Mandelbrots sets derived from different scales. The top image shows a Mandelbox generated with a scale of 2. The bottom image shows a scale of -3. Another commonly used scaled is -1.7

Scale = 2

Scale = -3