Max 5 API Reference

jit.fractal.c

/*
 * Copyright 2001-2005 - Cycling '74
 * Derek Gerstmann - derek@cycling74.com
 *
 * Common utilities for fractal functor objects
 *
 */

#include "jit.fractal.h"

/*************************************************************************/

t_jit_err jit_functor_fractal_exponents_init(
    t_jit_functor_combined_dynarray *exp,
    double detail, double roughness, double lacunarity)
{
    long i;
    t_jit_err err;
    double frequency = 1.0;
    double h = 1.0 - roughness; // fractal dimension
    long octaves = (long)detail + 1;

    // dispose allocated mem
    err = jit_functor_combined_dynarray_init(exp, octaves);
    if(err) return err;

    // compute weight for each frequency
    for ( i = 0; i < octaves; i++ )
    {
        exp->float64[i] = jit_math_pow( frequency, -h );
        exp->float32[i] = (float)exp->float64[i];
        exp->fixed[i] = DoubleToFixed(exp->float64[i]);
        frequency *= lacunarity;
    }

    return JIT_ERR_NONE;
}

t_jit_err jit_functor_fractal_rotations_init(
    t_jit_functor_fractal_combined_matrix_dynarray *x, 
    double octaves, long dimcount, long seed)
{
    long i;
    t_jit_err err;
    long count = (long)octaves;

    if(!x)
        return JIT_ERR_INVALID_PTR;

    // destroy any allocated mem
    if(x->m)
        jit_functor_fractal_rotations_destroy(x);
    x->m = NULL;

    // allocate
    x->count = count;
    x->m = (t_jit_functor_fractal_combined_matrix *)jit_newptr(x->count * sizeof(t_jit_functor_fractal_combined_matrix));
    if(!x->m)
        return JIT_ERR_INVALID_PTR;

    // init each matrix
    for(i = 0; i < x->count; i++) {
        x->m[i].cols = 0;
        x->m[i].rows = 0;
        x->m[i].fixed = NULL;
        x->m[i].float32 = NULL;
        x->m[i].float64 = NULL;
        err = jit_functor_fractal_rotation_matrix_init(&x->m[i], dimcount, seed);
        if(err) return err;
    }

    return JIT_ERR_NONE;
}

t_jit_err jit_functor_fractal_rotations_destroy(
    t_jit_functor_fractal_combined_matrix_dynarray *x)
{
    long i;

    if(!x)
        return JIT_ERR_INVALID_PTR;

    for(i = 0; i < x->count; i++)
        jit_functor_fractal_rotation_matrix_destroy(&x->m[i]);

    jit_disposeptr((char *)x->m);

    x->m = NULL;
    x->count = 0;

    return JIT_ERR_NONE;
}

/*
 * Derek Gerstmann - derek@cycling74.com
 *
 * Construct an n-dimensional random rotation matrix.
 *
 * This implementation is based on Greg Ferrar's proposed algorithm used in his
 * public domain Hypercube n-dimensional Java applet.  Comment snippet taken
 * from:  
 *
 *      http://www.flowerfire.com/ferrar/java/hypercuber/HyperCuber.java
 *
 * "Here is the algorithm used to build the matrix from scratch.  This algorithm was
 *  derived by examining correct rotation matrices up to size 7x7 (as derived by
 *  Mathematica) and looking for patterns.  The patterns were very obvious, but since
 *  the analysis was not mathematical, this algorithm has not yet been formally PROVEN.
 *  
 *  M[i,j] is the (i,j)th element of the rotation matrix, and rows and columns both
 *  start at 0.  s[i] and c[i] are the ith element of the sines and cosines matrices, 
 *  respectively.  s[0] is defined to be 1.0 (important for proper execution of step 5).
 *
 *  1. prod = 1; loop c from dim-1 to 1 step -1 { M[0,c] = -prod*s[c-1]; prod *= c[c-1]; }
 *  2. M[0, 0] = prod;
 *  3. loop r from 1 to dim-1 { M[r, r] = c[r-1] }
 *  4. loop r from 1 to dim-2 { loop c from r+1 to dim-1 { M[r, c] = 0 } }
 *  5. loop c from 0 to dim-2 { if (c==0) then prod = 1 else prod = -s[c-1];
 *                              loop r from c+1 to dim-1 { M[r, c] = prod*s[r-1]; prod *= c[r-1] } }
 *
 *  The matrix below is a sample 7x7 rotation matrix.  The entries indicate which element
 *  is generated by which step of the above algorithm.  For instance, element (0,0) is 2,
 *  indicating that the element in the 0th row and 0th column is generated by step 2 of
 *  the algorithm."
 *
 * column = 0           column = dim-1
 *     |                       |
 *
 *  [  2   1   1   1   1   1   1  ]   row = 0
 *  [  5   3   4   4   4   4   4  ]
 *  [  5   5   3   4   4   4   4  ]
 *  [  5   5   5   3   4   4   4  ]
 *  [  5   5   5   5   3   4   4  ]
 *  [  5   5   5   5   5   3   4  ]
 *  [  5   5   5   5   5   0   3  ]   row = dim-1
 * 
 */
t_jit_err jit_functor_fractal_rotation_matrix_init(
    t_jit_functor_fractal_combined_matrix *x, 
    long dimcount, long seed)
{
    long i, j, k, r, c;
    t_jit_err err;
    double p;
    double offset = JIT_MATH_F64_PI/2000;
    double angles[JIT_MATRIX_MAX_DIMCOUNT];

    // safety
    if(!x)
        return JIT_ERR_INVALID_PTR;

    // destroy any allocated memory
    err = jit_functor_fractal_rotation_matrix_destroy(x);
    if(err) return err;

    // allocate NxN matrix stored as M[row][col]
    x->cols = x->rows = dimcount;

    x->fixed = (long**)jit_newptr(x->rows * sizeof(long*));
    if(!x->fixed) return JIT_ERR_INVALID_PTR;
    for(i = 0; i < x->rows; i++) {
        x->fixed[i] = (long *) jit_newptr(x->cols * sizeof(long));
        if(!x->fixed[i]) return JIT_ERR_INVALID_PTR;
    }
    
    x->float32 = (float**)jit_newptr(x->rows * sizeof(float*));
    if(!x->float32) return JIT_ERR_INVALID_PTR;
    for(i = 0; i < x->rows; i++) {
        x->float32[i] = (float *) jit_newptr(x->cols * sizeof(float));
        if(!x->float32[i]) return JIT_ERR_INVALID_PTR;
    }
    
    x->float64 = (double**)jit_newptr(x->rows * sizeof(double*));
    if(!x->float64) return JIT_ERR_INVALID_PTR;
    for(i = 0; i < x->rows; i++) {
        x->float64[i] = (double *) jit_newptr(x->cols * sizeof(double));
        if(!x->float64[i]) return JIT_ERR_INVALID_PTR;
    }
    
    // construct a random rotation matrix
    jit_rand_setseed(seed);
    for(j = 0; j < dimcount; j++)
        angles[j] = (jit_rand() % 65535) / (double) 65535;

    // step 1
    p = 1.0;
    for (c = dimcount - 1; c >= 1; c--)
    {
        x->float64[0][c] = -p * jit_math_sin(angles[c-1] + offset);
        p *= jit_math_cos(angles[c-1] + offset);
    }
    
    // step 2
    x->float64[0][0] = p;

    // step 3
    for (r = 1; r <= dimcount-1; r++)
        x->float64[r][r] = jit_math_cos(angles[r-1] + offset);
            
    // step 4
    for (r = 1; r <= dimcount-2; r++)
        for (c = r+1; c <= dimcount-1; c++)
            x->float64[r][c] = 0.0;

    // step 5
    for (c = 0; c <= dimcount-2; c++)
    {
        if (c == 0)
            p = 1.0;
        else
            p = -jit_math_sin(angles[c-1]+ offset);
        for (r = c+1; r <= dimcount-1; r++)
        {
            x->float64[r][c] = p *jit_math_sin(angles[r-1] + offset);
            p *= jit_math_cos(angles[r-1] + offset);
        }
    }

    // copy and convert
    for(j = 0; j < x->rows; j++) {
        for(k = 0; k < x->cols; k++){
            x->float32[j][k] = (float)x->float64[j][k];
            x->fixed[j][k] = DoubleToFixed(x->float64[j][k]);
        }
    }
    return JIT_ERR_NONE;
}

t_jit_err jit_functor_fractal_rotation_matrix_destroy(
    t_jit_functor_fractal_combined_matrix *x)
{
    long i;

    if(!x)
        return JIT_ERR_INVALID_PTR;

    // dispose allocated mem
    if(x->fixed) {
        for(i = 0; i < x->rows; i++) {
            jit_disposeptr((char *)x->fixed[i]);
            x->fixed[i] = NULL;
        }
        jit_disposeptr((char *)x->fixed);
        x->fixed = NULL;
    }

    if(x->float32) {
        for(i = 0; i < x->rows; i++) {
            jit_disposeptr((char *)x->float32[i]);
            x->float32[i] = NULL;
        }
        jit_disposeptr((char *)x->float32);
        x->float32 = NULL;
    }

    if(x->float64) {
        for(i = 0; i < x->rows; i++) {
            jit_disposeptr((char *)x->float64[i]);
            x->float64[i] = NULL;
        }
        jit_disposeptr((char *)x->float64);
        x->float64 = NULL;
    }

    x->rows = x->cols = 0;
    return JIT_ERR_NONE;
}

/*************************************************************************/

Copyright © 2008, Cycling '74