END OF AN ERA, FRACTALFORUMS.COM IS CONTINUED ON FRACTALFORUMS.ORG

Re = -1.479,946,223,325,078,880,202,580,653,442,563,833,590,828,874,828,533,272,328,919,467,504,501,428,041,551,458,102,123,157,715,213,651,035,545,943,542,078,167,348,953,885,787,341,902,612,509,986,72
Im = 0.000,901,397,329,020,353,980,197,791,866,197,173,566,251,566,818,045,102,411,067,630,386,488,692,287,189,049,145,621,584,436,026,934,218,763,527,577,290,631,809,454,796,618,110,767,424,580,322,79

Magnification:
2^471
6.0971651373359223269171820894398 E141

/* -------------------------------------------------------------------- */
/* Determine whether a rectangular area is surrounded by all the same   */
/* color. If this case is true no point inside the area will get a      */
/* different color and thus there is no need to do any calculations for */
/* points inside.                                                       */
/* -------------------------------------------------------------------- */
/*                                                                      */
/* Test() is something like...                                          */
/*                                                                      */
/* -------------------------------------------------------------------+ */
/* -----------------------------------+-------------------------------- */
/* ----------------+--------------------------------------------------- */
/* -------+------------------------------------------------------------ */
/* ---+---------------------------------------------------------------- */
/* -+------------------------------------------------------------------ */
/* +------------------------------------------------------------------- */
/*                                                                      */
/* faster than testing every pixel, has same results                    */
/*                                                                      */

int QtfPainter::Test() // int xr1,int yr1,int xr2,int yr2
{
  int ti;
  int x = (int)(xr2-xr1)>>1; // half the width

  for (ti = xr2; ti >= xr1; ti-- ) {
    if ( tbuffer.pixel(ti, yr1) != coltmp) return 0;     // left top
    if ( tbuffer.pixel(ti, yr2) != coltmp) return 0;     // left bottom
    x >>= 1; ti -= x;                                    // minus 1/2 last width
  }

  int y = (int)(yr2-yr1)>>1; // half the height

  for (ti = yr2; ti > yr1; ti--) {
    if ( tbuffer.pixel(xr1, ti) != coltmp) return 0;      // right top
    if ( tbuffer.pixel(xr2, ti) != coltmp) return 0;      // right bottom
    y >>= 1; ti -= y;                                     // minus 1/2 last height
  }

  return 1;
}

/* -------------------------------------------------------------------- */
/* Recursive evaluation scheme briefly it does this:                    */
/* Called with the corners of an already calculated rectangular frame   */
/* it tests for identity of the color of all points on that frame.      */
/* If yes, fine! Just fill the points inside the area with this color   */
/* and return without further work.                                     */
/* If not, the area is halved and the function calls itself once for    */
/* each half until the size of the area degenerates to zero or the      */
/* first termination criterium jumps in.                                */
/* -------------------------------------------------------------------- */

void QtfPainter::FRecurse() // int xr1,int yr1,int xr2,int yr2
{
  double help1, help2;
  int xneu, yneu, tmp;
  int i;
  double dx = (remax - remin) / tbuffer.width();
  double dy = (immax - immin) / tbuffer.height();

  if (xr2 - xr1 > 1 && yr2 - yr1 > 1 ) { //&& ! STOPONBUT)
    coltmp = tbuffer.pixel(xr1,yr1);
    if ( Test() ) {
        // QImage has no fillRect() so fill it like so for now
       for( int y=yr2-1; y > yr1; y-- ) {
         for(int x=xr2-1; x > xr1; x-- ) {
           tbuffer.setPixel(x,y,coltmp);
         }
       }
    } else {
      if (xr2 - xr1 > yr2 - yr1) {
        xneu = (xr1 + xr2) >> 1;
        help1 = remin + xneu * dx;
        help2 = (yr1 + 1) * dy + immin;
        for (i = yr1 + 1; i < yr2; i++) {
          fracfunc (help1, help2);
          tbuffer.setPixel(xneu,i,colors[coltmp].rgb());
          help2 += dy;
        }
        tmp=xr2; xr2 = xneu; FRecurse (); xr2=tmp; // xr1, yr1, xneu, yr2
        tmp=xr1; xr1 = xneu; FRecurse (); xr1=tmp; // xneu, yr1, xr2, yr2
      } else {
        yneu = (yr1 + yr2) >> 1;
        help1 = immin + yneu * dy;
        help2 = (xr1 + 1) * dx + remin;
        for (i = xr1 + 1; i < xr2; i++) {
          fracfunc (help2, help1);
          tbuffer.setPixel(i,yneu,colors[coltmp].rgb());
          help2 += dx;
        }
        tmp=yr2; yr2 = yneu; FRecurse (); yr2=tmp; // xr1, yr1, xr2, yneu
        tmp=yr1; yr1 = yneu; FRecurse (); yr1=tmp; // xr1, yneu, xr2, yr2
      }
    }
  }

  return;
}

/***************************************************************************
                          qtfmandel.cpp  -  description
                             -------------------
    begin                : Wed Sep 5 2001
    copyright            : (C) 2001 by Dick.
    email                : ****@netscape.net
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program 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 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include "qtfpainter.h"

void QtfPainter::mandelfunc( double r, double i){

  uint   count = 0;
  double p = r;
  double q = i;
  double a;

  do
  {
    if ( p * p + q * q > divergence ) break;
    a  =  p;
    p +=  q;
    p *= (a - q);
    q *= (a + a);
    p +=  r;
    q +=  i;
  }
  while (count++ < maxiter );

  coltmp = (count >= maxiter) ? 0 : ( count % maxcol + 2 );

  return;
}