Yes, yet another page on zooming. Truth is, the methods I described on chapters 4 & 6 relied on observation, so they could in no way be considered precise. But I've come up with a technique that produces images so fast you won't believe your eyes!!! If you want to skip the explanations and check it out straight away, go see my zooming applet and try the default example.
I know Alex Boswell presented a zooming technique. It is also really fast, so it is only fair that I should mention it. It relies on the MetropolisHastings algorithm; here's a brief summary of his approach:
 Sample random points, and check if they paint anything on the magnified region. If so, sample nearby points; otherwise, sample other random points.
If you go deeper in the subject, you'll find it's a bit more complicated points have an "importance" based on their escape value and rendered iterates, etc., but you get the idea.
My method relies on some specific mathematic properties of M, so in order to fully understand the following explanations, you might need a bit of background. I'm not sure I mentioned it before, but there's no better place for that than MuEncy, Rob Munafo's Mandelbrot set Ecyclopedia.
The difficulty in zooming in on the BBrot lies in finding the correct regions regions that contain many points that toss a significant part of their iterates in the magnified area.
Probably because the BBrot technique paints points outside M (the Mandelbrot set), zooming methods have traditionally evaluated these. Well, as it turned out, points inside M can tell us more about where the aforementioned regions are.
See, the most important points to draw are those close to the borders of M, so it is inevitable that the magnified area will also contain iterates of points in mu atoms. If you turn that around, the following deduction can be made: the most important mu atoms will be surrounded by points inevitably drawn on the magnified area. Remember this is the basic principle behind my approach.
Now it's time to implement the theory, and see how well it works. Here's how I did it:
There are 2 main parts in the process: plane analysis and rendering.
Analyzing the plane: The whole plane is grid scanned, recording the period of points inside M. Then, using Newton's method, we can locate of all the found mu atoms' nuclei. We try iterating these, and if one of the Zs is close enough to the magnified area, we save its value. After some necessary filtering, we recursively scan smaller areas around these centerpoints, until we reach the size of the magnified region. The centerpoints found in this last pass determine which areas are going to be scanned for the render.
Rendering: We start off with a series of regions (whose centers are the points found in the plane analysis). There may be a lot of these, so to speed things up, we draw a map of each region. Maps are done using successive refinement and distance estimation; additionally, mapped points must draw in the magnified area. Finally, random points from all maps are plotted into the image. The smaller the dwell band spacing is, the more points will be plotted from that area.
Ok, this is it for the simple explanation (;,)). If you want to see how I coded that, feel free to check my zooming applet's source code.
There are a couple of issues worth discussing in my approach. The first and most obvious is that if the magnified area's mu atoms are very small compared to others close to them, they may not be detected. For example, some of the following features may be hard to spot:
 Embedded Julia sets.
 Minibrots in embedded Julia sets.
 Minibrots along the spike.
The solution is easy to do a finer grid scan. The limit is given by the computer's RAM. Another trouble spot is zooming in on the origin of coordinates (0.0, 0.0 i) the deeper you go, the more mu atoms will be mapped for the render, so the applet could run out of memory. Again, it's down to the computer's RAM.
Concerning the rendering process, the most important parameters are the maximum and minimum values of N (the dwell) for the color channels (red, green, and blue).
My zooming applet paints the BBrot, but you can see that with a few changes to the renderer's code, you could make a negative BBrot zoomer.
A Buddhagram zoomer can also be made using this pattern, but I reckon it'll take a bit more of clever thinking.
Here's some example images produced with my applet. All parameters are specified, in case you want to try something similar:
Scan grid width: 601
Detail: Very low Center: (1.35, 0i) Width: 0.125 (32 X) MinNMaxN red: 5  1000 MinNMaxN green: 10  3500 MinNMaxN blue: 15  6000 

Scan grid width: 601
Detail: Very low Center: (0.158428, 1.03335i) Width: 0.030476 (~131.25 X) MinNMaxN red: 30  12000 MinNMaxN green: 20  7000 MinNMaxN blue: 10  2000 

Scan grid width: 601
Detail: Very low Center: (1.477333, 0.0i) Width: 0.018443 (~216.9 X) MinNMaxN red: 0  15000 MinNMaxN green: 0  10000 MinNMaxN blue: 0  5000 

Scan grid width: 601
Detail: Very low Center: (1.25586, 0.38095 i) Width: 0.01054 (~379.5 X) MinNMaxN red: 0  10000 MinNMaxN green: 0  1000 MinNMaxN blue: 0  500 

Scan grid width: 1501
Detail: Very low Center: (0.0728025227119999, 1.1048127150340001i) Width: 0.032 (125 X) MinNMaxN red: 20  10000 MinNMaxN green: 20  15000 MinNMaxN blue: 20  20000 

Scan grid width: 601
Detail: Very low Center: (0.1915867, 0.8151886i) Width: 0.0001165 (~34335 X) MinNMaxN red: 200  10000 MinNMaxN green: 500  25000 MinNMaxN blue: 1000  50000 