apophysis7x/Plugin/dc_mandelbrot.c

/*
    Apophysis Plugin
    
    Mandelbrot Set Plugin v2 - Copyright 2008,2009 Jed Kelsey
    Changed to work with Apophysis 7X / DC in 2010 by Georg Kiehne
    
    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.
    
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

typedef struct 
{
	int dcm_iter;
	int dcm_miniter;
	int dcm_smooth_iter;
	int dcm_retries;
	int dcm_mode;
	int dcm_pow;
	int dcm_color_method;
	double dcm_invert;
	double dcm_xmin;
	double dcm_xmax;
	double dcm_ymin;
	double dcm_ymax;
	double dcm_scatter;
	double dcm_sx;
	double dcm_sy;
	double dcm_zscale;

	double x0, y0;
	double zs, sc;
} Variables;

#define _USE_MATH_DEFINES
#include "apoplugin.h"

APO_PLUGIN("dc_mandelbrot");
APO_VARIABLES(
    VAR_INTEGER_RANGE(dcm_iter, 5, INT_MAX, 25),
    VAR_INTEGER_RANGE(dcm_miniter, 0, INT_MAX, 1),
    VAR_INTEGER_RANGE(dcm_smooth_iter, 0, INT_MAX, 0),
    VAR_INTEGER_RANGE(dcm_retries, 0, INT_MAX, 50),
    VAR_INTEGER_RANGE(dcm_mode, 0, 5, 0),
    VAR_INTEGER_RANGE(dcm_pow, -6, 6, 2), // TODO: negative powers
    VAR_INTEGER_RANGE(dcm_color_method, 0, 7, 0),
    VAR_REAL_RANGE(dcm_invert, 0.0, 1.0, 0.0),
    VAR_REAL(dcm_xmin, -2.0),
    VAR_REAL(dcm_xmax, 2.0),
    VAR_REAL(dcm_ymin, -1.5),
    VAR_REAL(dcm_ymax, 1.5),
    VAR_REAL_RANGE(dcm_scatter, -1000.0, 1000.0, 0.0),
    
    // Following parameters don't affect iterations, just the output point positions.
    VAR_REAL(dcm_sx, 0.0),
    VAR_REAL(dcm_sy, 0.0),
    VAR_REAL(dcm_zscale, 0.0)
);

int PluginVarPrepare(Variation* vp)
{
	VAR(zs) = VVAR * VAR(dcm_zscale) / VAR(dcm_iter);
    VAR(sc) = VAR(dcm_scatter) / 10.0;
	return TRUE;
}

inline double fmod2(double h, double q) { return fmod(fabs(h),q); }

int PluginVarCalc(Variation* vp)
{
	double x=0.0, y=0.0, x1=0.0, y1=0.0, x2, y2, xtemp=0.0;
	double cx=0.0, cy=0.0;
	
	int maxiter = VAR(dcm_iter);
	int miniter = VAR(dcm_miniter); // = 0.1*(maxiter*(1-scatter));
	
	double xmax = VAR(dcm_xmax);
	double xmin = VAR(dcm_xmin);
	double ymax = VAR(dcm_ymax);
	double ymin = VAR(dcm_ymin);
	
	int maxRetries = VAR(dcm_retries);
	int mode = VAR(dcm_mode); /* 0=Mandelbrot, 1=Julia, 3=Tricorn(Mandelbar) */

	int color_method = VAR(dcm_color_method);
	double xp = 0.0, yp = 0.0;

	int smooth_iter=0, max_smooth_iter=VAR(dcm_smooth_iter);
	int inverted, iter=0, retries=0;
	int isblur = (VAR(sc)>=0);
	
	double smoothed_iter = 0.0, inv_iter = 1.0;
	double mag2 = 0.0;
	
	int m_power = VAR(dcm_pow);
	int m_power_abs = ((m_power<0) ? -m_power : m_power);

	inverted = random01() < VAR(dcm_invert);

	if (!isblur) {
		VAR(x0) = FTx;
		VAR(y0) = FTy;
	}

	do {
		if (VAR(sc)==0) {
			// Force selection of point at random
			VAR(x0) = VAR(y0) = 0;
		}

		if (VAR(x0)==0 && VAR(y0)==0) {
			// Choose a point at random
			VAR(x0) = (xmax-xmin)*random01() + xmin;
			VAR(y0) = (ymax-ymin)*random01() + ymin;
		} else {
			// Choose a point close to previous point
			VAR(x0) += VAR(sc)*(random01()-0.5);
			VAR(y0) += VAR(sc)*(random01()-0.5);
		}

		// default to Mandelbrot Set
		cx = x1 = x = xp = VAR(x0);
		cy = y1 = y = yp = VAR(y0);

		switch(mode) {
            case 1: // Julia Set
                cx = TM(e);
		        cy = TM(f);
		        break;
			case 2: // tricorn (Mandelbar)
				// leave as-is, handled below
				break;
			default: // Regular Mandelbrot set
				// Leave as-is
				break;
		}

		iter = smooth_iter = 0;

		while ( (((x2=x*x) + (y2=y*y) < 4) && (iter < maxiter)) || (smooth_iter++<max_smooth_iter) ) {
			if (smooth_iter==0)
				xp=x; yp=y;

			if (mode==2) y=-y;

			switch(m_power_abs) {
				case 3:
					xtemp = x*(x2 - 3*y2) + cx;
					y = y*(3*x2 - y2) + cy;
					x = xtemp;
					break;
				case 4:
					xtemp = (x2-y2)*(x2-y2)-4*x2*y2 + cx;
					y = 4*x*y*(x2 - y2) + cy;
					x = xtemp;
					break;
				case 5:
					xtemp = x2*x2*x - 10*x2*x*y2 + 5*x*y2*y2 + cx;
					y = 5*x2*x2*y - 10*x2*y2*y + y2*y2*y + cy;
					x = xtemp;
					break;
				case 6:
					xtemp = x2*x2*x2 - 15*x2*x2*y2 + 15*x2*y2*y2 - y2*y2*y2 + cx;
					y = 6*x2*x2*x*y - 20*x2*x*y2*y + 6*x*y2*y2*y + cy;
					x = xtemp;
					break;
				case 1:
					if ((m_power>0) && (iter<maxiter)) // (more iterations not helpful)
						iter = maxiter-1;
					break;
				case 2:
				default:
					xtemp = x2 - y2 + cx;
					y = 2*x*y + cy;
					x = xtemp;
					break;
			}

			if ((m_power<0) && (xtemp=x2+y2)>0) {
				x = x/xtemp;
				y = -y/xtemp;
			}

			iter++;
		}

		iter -= (smooth_iter-1);

		// could probably bypass check and always select next point at random
		if ( (miniter==0) || (!inverted && (iter>=maxiter)) /*|| (iter < miniter)*/ ) {
			VAR(x0) = VAR(y0) = 0; // Random point next time
		} else if ( (iter < miniter) || (inverted && (iter<maxiter/2)) ) {
			//if (retries>maxRetries-5) {
			//   VAR(x0) /= 100;
			//   VAR(y0) /= 100;
			//} else
			VAR(x0) = VAR(y0) = 0;
		}

		if (++retries > maxRetries)
			break;

	} while ((inverted && (iter < maxiter)) || (!inverted && ((iter >= maxiter) || ((miniter>0) && (iter < miniter)))));

	smoothed_iter = iter;
	if (max_smooth_iter>0) {
		// use Normalized Iteration Count Algorithm for smoothing
		mag2 = x2 + y2;
		if (mag2 > 1.1) //FIXME: change this back to if(mag2>4) ?
			smoothed_iter += 1 - log(log(mag2)/2)/M_LN2;
	}
	if (smoothed_iter>0)
		inv_iter = 1/smoothed_iter;
	else
		inv_iter = 1;

	// Adjust location of point according to sx,sy and final iterated point (x,y)
	// (use of inv_iter reduces effect of factor near regions of high gradient
	FPx += VVAR*(x1 + VAR(dcm_sx)*x*inv_iter);
	FPy += VVAR*(y1 + VAR(dcm_sy)*y*inv_iter);
	//FPx += VVAR*(x1 + VAR(dcm_sx)*x);
	//FPy += VVAR*(y1 + VAR(dcm_sy)*y);

	// TODO: add check to see whether this Apo supports 3D?
	if (VAR(dcm_zscale)) {
		FPz += smoothed_iter * VAR(zs);
	}

	// Allow plugin to influence coloring (-X- changed for Apo7X/DC)

	if (smoothed_iter<0) smoothed_iter=0;
	if (smoothed_iter>maxiter) smoothed_iter=maxiter;

	switch (color_method) {

		case 1: 
			// scale colormap indexing extent by the final angle of the iterated point 
			// after the extra "smoothing" iterations complete
			xtemp = 0.0;
			if (y != 0.0) xtemp = atan2(x,y) * M_1_2PI;
			TC = fmod2(xtemp, 1);
			break;
		case 2: 
			// scale colormap indexing extent by the angle of the iterated point at time of escape
			xtemp = 0.0;
			if (yp != 0.0) xtemp = atan2(xp,yp) * M_1_2PI;
			TC = fmod2(xtemp, 1);
			break;
		case 3: 
			// combination of mode 4 and 2
			xtemp = 0.0;
			if (y-yp != 0.0) xtemp = atan2(x-xp,y-yp) * M_1_2PI;
			TC = fmod2((smoothed_iter/maxiter * xtemp), 1);
			break;
		case 4: 
			// scale colormap indexing extent by the product of the scaled iteration count and 
			// the angle of the iterated point at time of escape
			xtemp = 0.0;
			if (yp != 0.0) xtemp = atan2(xp,yp) * M_1_2PI;
			TC = fmod2((smoothed_iter/maxiter * xtemp), 1);
			break;
		case 5: 
			// scale colormap indexing extent by a combination of scaled iteration count, 
			// the squared magnitude and adjusted angle of the iterated point at time of escape
			xtemp = 0.0;
			if (yp != 0.0) xtemp = (0.5 + atan2(xp,yp) * M_1_2PI) * (xp*xp+yp*yp);
			TC = fmod2((smoothed_iter/maxiter * xtemp), 1);
			break;
		case 6: 
			// scale colormap indexing extent by a combination of scaled iteration count and 
			// the squared magnitude of the iterated point at time of escape
			xtemp = xp*xp+yp*yp;
			TC = fmod2((smoothed_iter/maxiter * xtemp), 1);
			break;
		case 7: 
			// scale colormap indexing extent by a combination of scaled iteration count and 
			// the squared magnitude of the iterated point at time of escape
			// (slightly more relaxed color rolloff than case 6)
			xtemp = sqrt(xp*xp+yp*yp);
			TC = fmod2((smoothed_iter/maxiter * xtemp), 1);
			break;
		case 0: 
			// default coloring method: scale colormap indexing extent by the scaled "escape time" 
			// (iteration count)
		default:
			TC = fmod2(smoothed_iter/maxiter, 1);
			break;
	}

	return TRUE;
}