Q:

computing smooth color map using interpolation recursively

I am computing the mandelbrot set recursively and attempting to perform linear interpolation using the smooth coloring algorithm. However, this returns floating point RGB values which I can't put into the ppm image I am using so I am having to round off using int(), creating a smoother but yet still banded image. 
Are there any simpler ways that will produce a better non-banded image?
The second function is an extremely bad hack just playing around with ideas as the smooth algorithim seems to be producing rgb values in the range 256**3
Commented out the linear interpolation I was doing.
Here are my three functions:
  def linear_interp(self, color_1, color_2, i):
    r = (color_1[0] * (1 - i)) + (color_2[0] * i)
    g = (color_1[1] * (1 - i)) + (color_2[1] * i)
    b = (color_1[2] * (1 - i)) + (color_2[2] * i)

    return (int(abs(r)), int(abs(g)), int(abs(b)))

  def mandel(self, x, y, z, iteration = 0):
    mod_z = sqrt((z.real * z.real) + (z.imag * z.imag))
    #If its not in the set or we have reached the maximum depth
    if  abs(z) >= 2.00 or iteration == DEPTH:
        if iteration == DEPTH:
            mu = iteration
        else:
            mu = iteration + 1 - log(log(mod_z)) / log(2)

    else:
        mu = 0
        z = (z * z) + self.c
        self.mandel(x, y, z, iteration + 1)
    return mu

 def create_image(self):
    begin = time.time() #For computing how long it took (start time)
    self.rgb.palette = []
    for y in range(HEIGHT):
        self.rgb.palette.append([]) #Need to create the rows of our ppm
        for x in range(WIDTH):
            self.c =  complex(x * ((self.max_a - self.min_a) / WIDTH) + self.min_a, 
                              y * ((self.max_b - self.min_b) / HEIGHT) + self.min_b)

            z = self.c

            q = (self.c.real - 0.25)**2 + (self.c.imag * self.c.imag)
            x = self.c.real
            y2 = self.c.imag * self.c.imag

            if not (q*(q + (x - 0.25)) < y2 / 4.0 or (x + 1.0)**2 + y2 <0.0625): 
                mu = self.mandel(x, y, z, iteration = 0)
                rgb = self.linear_interp((255, 255, 0), (55, 55, 0), mu)
                self.rgb.palette[y].append(rgb)
            else:
                self.rgb.palette[y].append((55, 55, 0))
            if self.progress_bar != None:
                self.progress_bar["value"] = y
                self.canvas.update()

The image I am getting is below:

A:

I think this is the culprit:
else:
    mu = 0
    self.mandel(x, y, z, iteration + 1)
return mu

This isn't passing down the value of mu from the recursive call correctly, so you're getting black for everything that doesn't bottom out after 1 call. Try
else:
    ...
    mu = self.mandel(x, y, z, iteration + 1)
return mu

