DCGnarlyFunc.java

/*
  JWildfire - an image and animation processor written in Java
  Copyright (C) 1995-2011 Andreas Maschke

  This is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser
  General Public License as published by the Free Software Foundation; either version 2.1 of the
  License, or (at your option) any later version.

  This software 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License along with this software;
  if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jwildfire.create.tina.variation;

import static org.jwildfire.base.mathlib.MathLib.M_PI;
import static org.jwildfire.base.mathlib.MathLib.fabs;
import static org.jwildfire.base.mathlib.MathLib.fmod;
import static org.jwildfire.base.mathlib.MathLib.sin;
import static org.jwildfire.base.mathlib.MathLib.cos;
import static org.jwildfire.base.mathlib.MathLib.tan;
import static org.jwildfire.base.mathlib.MathLib.sqr;
import static org.jwildfire.base.mathlib.MathLib.sqrt;

import org.jwildfire.base.Tools;

import static org.jwildfire.base.mathlib.MathLib.log;

import org.jwildfire.create.tina.base.Layer;
import org.jwildfire.create.tina.base.XForm;
import org.jwildfire.create.tina.base.XYZPoint;

public class DCGnarlyFunc extends VariationFunc {
    private static final long serialVersionUID = 1L;

    private static final String PARAM_MODE = "mode";
    private static final String PARAM_SCALEX = "scalex";
    private static final String PARAM_SCALEY = "scaley";
    private static final String PARAM_FREQX1 = "freqx1";
    private static final String PARAM_FREQY1 = "freqy1";
    private static final String PARAM_FREQX2 = "freqx2";
    private static final String PARAM_FREQY2 = "freqy2";
    private static final String PARAM_FREQX3 = "freqx3";
    private static final String PARAM_FREQY3 = "freqy3";
    private static final String PARAM_DC = "dc";
    private static final String PARAM_COLOR1 = "color1";
    private static final String PARAM_COLOR2 = "color2";
    private static final String PARAM_FMAG = "fmag";
    private static final String PARAM_DISTORT = "distort";
    private static final String PARAM_BLUR = "blur";
      private static final String PARAM_SCALEZ = "scale_z";
      private static final String PARAM_OFFSETZ = "offset_z";
      private static final String PARAM_RESETZ = "reset_z";

    private static final String[] paramNames = { PARAM_MODE, PARAM_SCALEX, PARAM_SCALEY, PARAM_FREQX1, PARAM_FREQY1,
            PARAM_FREQX2, PARAM_FREQY2, PARAM_FREQX3, PARAM_FREQY3, PARAM_DC, PARAM_COLOR1, PARAM_COLOR2,
            PARAM_FMAG, PARAM_DISTORT, PARAM_BLUR, PARAM_SCALEZ, PARAM_OFFSETZ, PARAM_RESETZ };

    private int mode = 1;
    private double scalex = 0.05;
    private double scaley = 0.05;
    private double freqx1 = 3.5;
    private double freqy1 = 3.5;
    private double freqx2 = 2;
    private double freqy2 = 2;
    private double freqx3 = 5;
    private double freqy3 = 5;
    private int dc = 1;
    private double color1 = 5;
    private double color2 = 5;
    private double fmag = 1;
    private double distort = 0.0;
    private double blur = 5.0;
    private double scale_z = 0.0;
    private double offset_z = 0.0;
    private int reset_z = 0;

    private final double gauss_rnd[] = new double[6];
    private int gauss_N;

    @Override
    public void transform(FlameTransformationContext pContext, XForm pXForm, XYZPoint pAffineTP, XYZPoint pVarTP, double pAmount) {
        // dc_gnarly by Brad Stefanov and Rick Sidwell
        // inspired by techniques and formulas by Tatyana Zabanova, Georg Kiehne, Clifford Pickover, and Mark Townsend

        double x0 = pAffineTP.x;
        double y0 = pAffineTP.y;

        if (blur > 0) {
          double r = pContext.random() * 2 * M_PI;
          double sina = sin(r);
          double cosa = cos(r);
          r = blur * (gauss_rnd[0] + gauss_rnd[1] + gauss_rnd[2] + gauss_rnd[3] + gauss_rnd[4] + gauss_rnd[5] - 3);
          gauss_rnd[gauss_N] = pContext.random();
          gauss_N = (gauss_N + 1) & 5;

          x0 += r * cosa;
          y0 += r * sina;
        }
        else if (blur < 0) {
          x0 += pContext.random() * blur * 2 - blur;
          y0 += pContext.random() * blur * 2 - blur;
        }

        double x1, y1;
        switch (mode) {
        case 1:
            x1 = cos(freqx1 * y0 + sin(freqx2 * (y0 + sin(freqx3 * y0)))) * scalex;
            y1 = cos(freqy1 * x0 + sin(freqy2 * (x0 + sin(freqy3 * x0)))) * scaley;
            break;
        case 2:
            x1 = sin(freqx1 * y0 + sin(freqx2 * (y0 + cos(freqx3 * y0)))) * scalex;
            y1 = sin(freqy1 * x0 + sin(freqy2 * (x0 + cos(freqy3 * x0)))) * scaley;
            break;
        case 3:
            x1 = cos(freqx1 * y0 + sin(freqx2 * (x0 + sin(freqx3 * y0)))) * scalex;
            y1 = cos(freqy1 * x0 + sin(freqy2 * (y0 + sin(freqy3 * x0)))) * scaley;
            break;
        case 4:
            x1 = sin(freqx1 * y0 + sin(sqrt(fabs(freqx2 * (y0 + cos(freqx3 * y0)))))) * scalex;
            y1 = sin(freqy1 * x0 + sin(sqrt(fabs(freqy2 * (x0 + cos(freqy3 * x0)))))) * scaley;
            break;
        case 5:
            x1 = cos(freqx1 * y0 + asinh(freqx2 * (y0 + sin(freqx3 * y0)))) * scalex;
            y1 = cos(freqy1 * x0 + asinh(freqy2 * (x0 + sin(freqy3 * x0)))) * scaley;
            break;
        case 6:
            x1 = cos(freqx1 * y0 + tan(freqx2 * (y0 + sin(freqx3 * y0)))) * scalex;
            y1 = cos(freqy1 * x0 + tan(freqy2 * (x0 + sin(freqy3 * x0)))) * scaley;
            break;
        case 7:
            x1 = sin(freqx1 * y0 + sin(sqr(freqx2 * (y0 + cos(freqx3 * y0))))) * scalex;
            y1 = sin(freqy1 * x0 + sin(sqr(freqy2 * (x0 + cos(freqy3 * x0))))) * scaley;
            break;
        case 8:
            x1 = sin(freqx1 * y0 + sin(sqr(freqx2 * (x0 + cos(freqx3 * y0))))) * scalex;
            y1 = sin(freqy1 * x0 + sin(sqr(freqy2 * (y0 + cos(freqy3 * x0))))) * scaley;
            break;
        default:
            x1 = sin(freqx1 * y0) * scalex;
            y1 = sin(freqy1 * x0) * scaley;
            break;
        }

        double s1 = log(sqrt(sqr(x1) + sqr(y1))) * distort;

        pVarTP.x += pAmount * (x0 + x1) / 2;
        pVarTP.y += pAmount * (y0 + y1) / 2;

        if (dc != 0) {
            pVarTP.color = fmod(fabs(cos(x0 + x1 * color1 + s1) + sin(y0 + y1 * color2 + s1)), fmag);
        }

        double dz = pVarTP.color * scale_z + offset_z;
        if (reset_z > 0) {
          pVarTP.z = dz;
        }
        else {
          pVarTP.z += dz;
        }
    }

    @Override
    public String[] getParameterNames() {
        return paramNames;
    }

    @Override
    public Object[] getParameterValues() {
        return new Object[] { mode, scalex, scaley, freqx1, freqy1, freqx2, freqy2, freqx3, freqy3,
                dc, color1, color2, fmag, distort, blur, scale_z, offset_z, reset_z };
    }

    @Override
    public void setParameter(String pName, double pValue) {
        if (PARAM_MODE.equalsIgnoreCase(pName))
            mode = Tools.limitValue(Tools.FTOI(pValue), 0, 8);
        else if (PARAM_SCALEX.equalsIgnoreCase(pName))
            scalex = pValue;
        else if (PARAM_SCALEY.equalsIgnoreCase(pName))
            scaley = pValue;
        else if (PARAM_FREQX1.equalsIgnoreCase(pName))
            freqx1 = pValue;
        else if (PARAM_FREQY1.equalsIgnoreCase(pName))
            freqy1 = pValue;
        else if (PARAM_FREQX2.equalsIgnoreCase(pName))
            freqx2 = pValue;
        else if (PARAM_FREQY2.equalsIgnoreCase(pName))
            freqy2 = pValue;
        else if (PARAM_FREQX3.equalsIgnoreCase(pName))
            freqx3 = pValue;
        else if (PARAM_FREQY3.equalsIgnoreCase(pName))
            freqy3 = pValue;
        else if (PARAM_DC.equalsIgnoreCase(pName))
            dc = Tools.limitValue(Tools.FTOI(pValue), 0, 1);
        else if (PARAM_COLOR1.equalsIgnoreCase(pName))
            color1 = pValue;
        else if (PARAM_COLOR2.equalsIgnoreCase(pName))
            color2 = pValue;
        else if (PARAM_FMAG.equalsIgnoreCase(pName))
            fmag = Tools.limitValue(pValue, 0.05, 1);
        else if (PARAM_DISTORT.equalsIgnoreCase(pName))
            distort = pValue;
        else if (PARAM_BLUR.equalsIgnoreCase(pName))
            blur = pValue;
        else if (PARAM_SCALEZ.equalsIgnoreCase(pName))
            scale_z = pValue;
          else if (PARAM_OFFSETZ.equalsIgnoreCase(pName))
            offset_z = pValue;
          else if (PARAM_RESETZ.equalsIgnoreCase(pName))
            reset_z = Tools.limitValue(Tools.FTOI(pValue), 0, 1);
        else
            throw new IllegalArgumentException(pName);
    }

    @Override
    public String getName() {
        return "dc_gnarly";
    }

    @Override
    public void init(FlameTransformationContext pContext, Layer pLayer, XForm pXForm, double pAmount) {


        gauss_rnd[0] = pContext.random();
        gauss_rnd[1] = pContext.random();
        gauss_rnd[2] = pContext.random();
        gauss_rnd[3] = pContext.random();
        gauss_rnd[4] = pContext.random();
        gauss_rnd[5] = pContext.random();
        gauss_N = 0;
    }

    public static double asinh(double x) {
        return log(x + sqrt(x * x + 1.0));
    }

}