FloatDict getFoldsParameters() {
  FloatDict f = new FloatDict();
  
 f.set("lines_scale",random(0.01,0.5));
 f.set("lines_squared",random(0,1) < 0.5 ? 1 : 0);
 f.set("flower_petals",round(random(3,13)));
 f.set("flower_holes",random(-0.2,1));
 f.set("waves_b",random(-0.8,0.8));
 f.set("waves_e",random(-0.8,0.8));
 f.set("waves_c",random(-0.8,0.8));
 f.set("waves_f",random(-0.8,0.8));
 f.set("popcorn_c",random(-0.8,0.8));
 f.set("popcorn_f",random(-0.8,0.8)); 
 f.set("rings_c",random(-0.9,0.9));
 f.set("fan_c",random(-0.9,0.9));
 f.set("fan_f",random(-0.8,0.8));
 f.set("blob_low",random(0.2,0.7));
 f.set("blob_high",random(0.8,1.2));
 f.set("blob_waves",round(random(2,7)));
 f.set("pdj_a",random(-3.0,3.0));
 f.set("pdj_b",random(-3.0,3.0));
 f.set("pdj_c",random(-3.0,3.0));
 f.set("pdj_d",random(-3.0,3.0)); 
 f.set("fan2_x",random(-1,1));
 f.set("fan2_y",random(2,7));  
 f.set("rings2_val",random(0.1,1.2));
 f.set("perspective_angle",random(0.3,1.0));
 f.set("perspective_dist",random(1.0,3.0));
 f.set("julian_power",random(0,1)<0.5? (int)random(4,10) : -(int)random(4,10));
 f.set("julian_dist",random(0.5,3.0));
 f.set("juliascope_power",random(0,1)<0.5? (int)random(4,10) : -(int)random(4,10));
 f.set("juliascope_dist",random(0.5,2.0));
 f.set("radialblur_angle",HALF_PI * random(-1,1));
 f.set("pie_slices",(int)random(3,10));
 f.set("pie_rotation",random(-2,2));
 f.set("pie_thickness",random(0.2,0.8));
 f.set("ngon_sides",(int)random(3,9));
 f.set("ngon_power",random(1.01, 4.0));
 f.set("ngon_circle",random(0.5, 1.5));
 f.set("ngon_corners",random(0.5, 1.5));
 f.set("curl_c1",random(0.1,0.7));
 f.set("curl_c2",random(0.1,0.7));
 f.set("wedgejulia_count",(int)random(2,7));
 f.set("wedgejulia_angle",random(-3,3));
 f.set("wedgejulia_power",random(0,1)<0.5?(int)random(2,7):-(int)random(2,7));
 f.set("wedgejulia_dist",random(1,4));
 f.set("circus_size",random(0.2,1.2));
 f.set("rectangles_x",random(0.1,1));
 f.set("rectangles_y",random(0.1,1));
 f.set("arch_weight",random(0.4,1));
 f.set("rays_weight",random(0.4,1));
 f.set("blade_weight",random(0.4,1));
 f.set("secant_weight",random(0.4,1));
 f.set("twintrian_weight",random(0.4,1));
 f.set("disc2_rot",random(-2,2));
 f.set("disc2_twist",random(-8,8)); 
 f.set("supershape_rnd",random(1)<0.8?0:random(0,0.3));
 f.set("supershape_m",random(1,20));
 f.set("supershape_n1",random(0.5,20));
 f.set("supershape_n2",random(0.5,20));
 f.set("supershape_n3",random(0.5,20));
 f.set("supershape_holes",random(-1,1));
 f.set("conic_holes",random(0,1));
 f.set("conic_eccentricity",random(0.3,1.0));  
 f.set("parabola_width",random(0,1) < 0.5 ? random(1,3) : -random(1,3));  
 f.set("parabola_height",random(0,1) < 0.5 ? random(1,3) : -random(1,3));
 f.set("bent2_x",random(-1.5,1.5));
 f.set("bent2_y",random(-1.5,1.5));
 f.set("bipolar_shift",random(-1.5,1.5));  
 f.set("cell_size",random(-2.5,2.5));
 f.set("cpow_r",random(1,3));
 f.set("cpow_i",random(-0.25,0.25));
 f.set("cpow_power",(int)random(1,5));
 f.set("loonie_weight",random(0.8,1.6));
 f.set("scry_weight",random(0.4,1));
 f.set("curve_xamp",random(-2.5,2.5));
 f.set("curve_yamp",random(-2.5,2.5));
 f.set("curve_xlength",random(0.9,2.7)); 
 f.set("curve_ylength",random(0.9,2.7));
 f.set("escher_beta",random(-3,3));
 f.set("lazysuzan_spin",random(-3,3));
 f.set("lazysuzan_space",random(-1,2));
 f.set("lazysuzan_twist",random(-2,2));
 f.set("lazysuzan_x",random(-0.5,0.5));
 f.set("lazysuzan_y",random(-0.5,0.5));
 f.set("lazysuzan_weight",random(0.4,1));
 f.set("modulus_x",random(0.8,1.5)*(random(0,1)<0.5?-1:1));
 f.set("modulus_y",random(0.8,1.5)*(random(0,1)<0.5?-1:1));
 f.set("oscilloscope_separation",random(0.01,2));
 f.set("oscilloscope_frequency",random(-8,8));
 f.set("oscilloscope_amplitude",random(0.4,3));
 f.set("oscilloscope_damping",random(0,1));
 f.set("popcorn2_x",random(-1,1));
 f.set("popcorn2_y",random(-1,1));
 f.set("popcorn2_c",random(-5,5));
 f.set("separation_x",random(0,1));
 f.set("separation_y",random(0,1));
 f.set("separation_xinside",random(-1,1));
 f.set("separation_yinside",random(-1,1));
 f.set("split_xsize",random(-0.8,0.8));
 f.set("split_ysize",random(-0.8,0.8));
 f.set("splits_x",random(-1,1));
 f.set("splits_y",random(-1,1));
 f.set("stripes_space",random(-0.8,0.8));
 f.set("stripes_warp",random(-4,4));
 f.set("wedge_angle",random(-3,3));
 f.set("wedge_hole",random(-0.5,0.5));
 f.set("wedge_count",floor(random(1,6.9)));
 f.set("wedge_swirl",random(-1,1));
 f.set("wedgesph_angle",random(-3,3));
 f.set("wedgesph_hole",random(-0.5,0.5));
 f.set("wedgesph_count",floor(random(1,6.9)));
 f.set("wedgesph_swirl",random(-1,1));
 f.set("whorl_inside",random(-2,2));
 f.set("whorl_outside",random(-2,2));
 f.set("whorl_weight",random(0.8,2));
 f.set("waves2_freqx",random(0.01,4));
 f.set("waves2_freqy",random(0.01,4));
 f.set("waves2_scalex",random(0.5,1.5));
 f.set("waves2_scaley",random(0.5,1.5));
 f.set("auger_freq",floor(random(3,7.9)));
 f.set("auger_scale",random(0.1,0.8));
 f.set("auger_sym",random(-1,1));
 f.set("auger_weight",random(-1,1));
 f.set("flux_spread",random(0.5,1));
 f.set("flux_weight",random(0.4,1));
 f.set("mobius_re_a",random(-1,1));
 f.set("mobius_im_a",random(-1,1));
 f.set("mobius_re_b",random(-1,1));
 f.set("mobius_im_b",random(-1,1));
 f.set("mobius_re_c",random(-1,1));
 f.set("mobius_im_c",random(-1,1));
 f.set("mobius_re_d",random(-1,1));
 f.set("mobius_im_d",random(-1,1));
 f.set("bcollide_num",random(1.1,8.1));
 f.set("bcollide_a",random(-0.5,1));
 f.set("bmod_radius", random(0.01, TWO_PI));
 f.set("bmod_distance", random(0.01, 2));
 f.set("bswirl_in", random(-2,2));
 f.set("bswirl_out", random(-2,2));
 f.set("btransform_rotate", random(-TWO_PI, TWO_PI));
 f.set("btransform_power", random(1,6));
 f.set("btransform_move", random(-0.5,0.5));
 f.set("btransform_split", random(-1,1));
 f.set("bwraps7_cellsize", random(0.4,2));
 f.set("bwraps7_space", random(0,0.8));
 f.set("bwraps7_gain",random(0.5,2.5));
 f.set("bwraps7_inner_twist", random(-PI,PI));
 f.set("bwraps7_outer_twist", random(-PI,PI));
 f.set("barycentroid_a",random(-1,1));
 f.set("barycentroid_b",random(-1,1));
 f.set("barycentroid_c",random(-1,1));
 f.set("barycentroid_d",random(-1,1));
 f.set("blocky_x", (random(0,1)<0.5?1.0:-1.0) * random(0.9,1));
 f.set("blocky_y", (random(0,1)<0.5?1.0:-1.0) * random(0.9,1));
 f.set("blocky_mp",(random(0,1)<0.5?1.0:-1.0) * random(1.5,6));
 f.set("blocky_weight",random(0.4,1));
 f.set("blurzoom_length",random(-1.0,1.5));
 f.set("blurzoom_x", random(-1,1));
 f.set("blurzoom_y", random(-1,1));
 f.set("boarders2_c",random(0.1,0.9));
 f.set("boarders2_left",random(0.1,0.9));
 f.set("boarders2_right",random(0.1,0.9));
 f.set("cannabiscurvewf_filled",random01());
 f.set("checks_x", random(0.2,1.5));
 f.set("checks_y", random(0.2,1.5));
 f.set("checks_size", random(0.4,1.5));
 f.set("checks_rnd", random(0,1)<0.5?0.0:1.0);
 f.set("circlecrop_radius", random(1,2));
 f.set("circlecrop_zero", random01());
 f.set("circlecrop_scatterarea", random(-1,1));
 f.set("circlecrop_x", random(-0.5,0.5));
 f.set("circlecrop_y", random(-0.5,0.5));
 f.set("circlize_hole",random(-2,2));
 f.set("cloverleaf_filled",random01());
 f.set("collideoscope_a", random(0,1));
 f.set("collideoscope_num", (int)random(1,10));
 f.set("crackle_cellsize", random(0.02,1.0));
 f.set("crackle_power", random(0.001,2));
 f.set("crackle_distort", random(-2,2));
 f.set("crackle_scale",random(0.1,10));
 f.set("crackle_z",random(-15,15));
 f.set("crop_left",random(-2.0,-0.5));
 f.set("crop_right",random(0.5,2.0));
 f.set("crop_top",random(-2.0,-0.5));
 f.set("crop_bottom",random(0.5,2.0));
 f.set("crop_scatter_area",random(-2,2));
 f.set("crop_zero",random01());
 f.set("dcperlin_shape",(int)random(0,3)); // 0,1,2
 f.set("dcperlin_map",(int)random(0,7)); // 0-5
 f.set("dcperlin_select_centre", random(-1,1));
 f.set("dcperlin_select_range", random(0.1,2.0));
 f.set("dcperlin_edge", random(0.5,2.5));
 f.set("dcperlin_scale", random(0.1,3.0));
 f.set("dcperlin_octaves",(int)random(1,4));
 f.set("dcperlin_freqs",random(0.25,0.75));
 f.set("dcperlin_z",random(-10,10));
 f.set("dcperlin_select_bailout",random(2,100));
 f.set("dcperlin_centre", random(-0.3,0.3));
 f.set("dcperlin_range", random(0.5,1.5));
 f.set("dlawf_buffersize",random(500,1500));
 f.set("dlawf_maxiter", random(3000,10000));
 f.set("dlawf_seed", (1.0+millis()) * (1.0+frameCount) % random(1000,1.0e20));
 f.set("dlawf_scale", random(10,20));
 f.set("ecollide_num", (int)random(1,10));
 f.set("ecollide_a", random(-1,1));
 f.set("ejulia_power",random(-6.6));
 f.set("emod_radius",random(0.3,2));
 f.set("emod_distance",random(-1,1));
 f.set("emotion_move",random(-0.5,0.5));
 f.set("emotion_rotate",random(-PI,PI));
 f.set("epush_dist", random(0.5,1.2) * (random01() * 2.0 - 1.0));
 f.set("epush_push", random(-1,1));
 f.set("epush_rotate", random(-PI,PI));
 f.set("erotate_rotate", random(0,TWO_PI));
 f.set("escale_scale", random(0.6,1.5));
 f.set("escale_angle", random(-PI,PI));
 f.set("eswirl_in", random(-0.5,0.5));
 f.set("eswirl_out", random(-1,1));
 f.set("eclipse_shift", random(-2,2));
 f.set("eclipse_weight", random(0.5,2));
 f.set("epispiral_n",(int)random(2,15));
 f.set("epispiral_thickness",random(-1,1));
 f.set("epispiral_holes", random(-1,0));
 f.set("epispiralwf_waves",(int)random(2,15));
 f.set("fibonacci2_sc",random(-1,1));
 f.set("fibonacci2_sc2",random(-1,1));
 f.set("flipcircle_weight",random(0.4,1.5));
 f.set("fourth_spin",random(0,TWO_PI));
 f.set("fourth_space", random(-1,1));
 f.set("fourth_twist", random(0,TWO_PI));
 f.set("fourth_x", random(-0.5,0.5));
 f.set("fourth_y", random(-0.5,0.5));
 f.set("fourth_weight", random(0.4,1.0));
 f.set("gdoffs_delta_x", random(8,12.0));
 f.set("gdoffs_delta_y", random(8,12.0));
 f.set("gdoffs_area_x", random(2.0,3.0));
 f.set("gdoffs_area_y", random(2.0,3.0));
 f.set("gdoffs_center_x", randomGaussian()/3);
 f.set("gdoffs_center_y", randomGaussian()/3);
 f.set("gdoffs_gamma", (int)random(1,7));
 f.set("gdoffs_square", (int)random(0,2));
 f.set("glynnsim1_radius", random(1.0,2.0));
 f.set("glynnsim1_radius1", random(0.05,0.8));
 f.set("glynnsim1_phi1", random(0,360));
 f.set("glynnsim1_thickness", random(0,1));
 f.set("glynnsim1_pow",random(-3,3));
 f.set("glynnsim1_contrast",random(0,1));
 f.set("glynnsim2_radius", random(0.5,2.0));
 f.set("glynnsim2_phi1", random(0,360));
 f.set("glynnsim2_phi2", random(0,360));
 f.set("glynnsim2_thickness", random(0.01,1.0));
 f.set("glynnsim2_pow",random(-3,3));
 f.set("glynnsim2_contrast",random(0,1));
 f.set("glynnsim3_radius", random(0.5,2.0));
 f.set("glynnsim3_thickness", random(0.01,1.0));
 f.set("glynnsim3_thickness2", random(0.01,1.0));
 f.set("glynnsim3_pow",random(-3,3));
 f.set("glynnsim3_contrast",random(0,1));
 f.set("heartwf_scale_x",random(0.7,1.3));
 f.set("heartwf_shift_t",random(-0.5,0.5));
 f.set("heartwf_scale_t_left", random(0.7,1.3));
 f.set("heartwf_scale_t_right", random(0.7,1.3));
 f.set("hexes_cellsize", random(0.5,2.0));
 f.set("hexes_power", random(0.3,6.0));
 f.set("hexes_rotate", random(0, TWO_PI));
 f.set("hexes_scale",random(0.5,2.0));
 f.set("hypertile1_p",random(3,8));
 f.set("hypertile1_q",random(3,8));
 f.set("hypertile2_p",random(3,8));
 f.set("hypertile2_q",random(3,8));
 f.set("hypertile_p",random(3,8));
 f.set("hypertile_q",random(3,8));
 f.set("hypertile_n",random(0,8));
 f.set("jaccn_k",random(-1.0,1.0));
 f.set("jacdn_k",random(-1.0,1.0));
 f.set("jacsn_k",random(-1.0,1.0));
 f.set("juliac_re",(random(1)<0.5?1:-1) * ((int)(random(4.0,24.0)) * 0.25 ));
 f.set("juliac_im", random(-3,3));
 f.set("juliac_dist", random(-2,2));
 f.set("asteria_alpha",random(0,2));
 f.set("bwrands_cellsize",random(0.5,2.0));
 f.set("bwrands_space",random(0,1));
 f.set("bwrands_gain",random(0.8,2.0));
 f.set("bwrands_inner_twist",random(0,TWO_PI));
 f.set("bwrands_outer_twist",random(0,TWO_PI));
 f.set("bwrands_seed",(int)random(0,MAX_INT));
 f.set("bwrands_rrot",random(0,1));
 f.set("bwrands_rmin",random(0,1));
 f.set("bwrands_loonie_chance",random(0,1));
 f.set("bwrands_petals_chance",random(0,1));
 f.set("bwrands_minpetals",(int)random(1,20));
 f.set("bwrands_maxpetals", f.get("bwrands_minpetals")+(int)random(1,20));
 f.set("circlize2_hole",random(-2,2));
 f.set("funnel_effect",random(0,8));
 f.set("funnel2_effect",random(0,8));
 f.set("juliaq_power", ((random(1)<0.5?-1.0:1.0)*random(1.5,10)));
 f.set("juliaq_divisor", random(1,5));
 f.set("kaleidoscope_pull",random(-1,1));
 f.set("kaleidoscope_rotate",random(-PI,PI));
 f.set("kaleidoscope_lineup",random(-1,1));
 f.set("kaleidoscope_x",random(-1,1));
 f.set("kaleidoscope_y",random(-1,1));
 f.set("layeredspiral_radius",((random(1)<0.5?-1.0:1.0)*random(0.9,1.3)));
 f.set("vibration2_dir",random(0, TWO_PI));
 f.set("vibration2_angle",random(0,TWO_PI));
 f.set("vibration2_freq",random(-1.1,1.1));
 f.set("vibration2_amp",random(-1,1));
 f.set("vibration2_phase",random(-1,1));
 f.set("vibration2_dir2",random(0,TWO_PI));
 f.set("vibration2_angle2",random(0,TWO_PI));
 f.set("vibration2_freq2",random(-1.1,1.1));
 f.set("vibration2_amp2",random(-1,1));
 f.set("vibration2_phase2",random(-1,1));
 f.set("vibration2_dm",random(-1,1));
 f.set("vibration2_dmfreq",random(-1,1));
 f.set("vibration2_tm",random(-1,1));
 f.set("vibration2_tmfreq",random(-1,1));
 f.set("vibration2_fm",random(-1,1));
 f.set("vibration2_fmfreq",random(-1,1));
 f.set("vibration2_am",random(-1,1));
 f.set("vibration2_amfreq",random(-1,1));
 f.set("vibration2_d2m",random(-1,1));
 f.set("vibration2_d2mfreq",random(-1,1));
 f.set("vibration2_t2m",random(-1,1));
 f.set("vibration2_t2mfreq",random(-1,1));
 f.set("vibration2_f2m",random(-1,1));
 f.set("vibration2_f2mfreq",random(-1,1));
 f.set("vibration2_a2m",random(-1,1));
 f.set("vibration2_a2mfreq",random(-1,1));
 f.set("lazyjess_n",(int)random(2,10));
 f.set("lazyjess_spin",random(-PI,PI));
 f.set("lazyjess_space", random(-0.5,0.5));
 f.set("lazyjess_corner",(int)random(1,10));
 f.set("lazyjess_weight",random(0.8,1.2)); 
 f.set("lineart_powx",random(0.5,1.5));
 f.set("lineart_powy",random(0.5,1.5));
 f.set("lissajous_tmin",random(-TWO_PI,0));
 f.set("lissajous_tmax",random(0,TWO_PI)+f.get("lissajous_tmin"));
 f.set("lissajous_a",random(-5,5));
 f.set("lissajous_b",random(-5,5));
 f.set("lissajous_c",random(-1,1));
 f.set("lissajous_d",random(-5,5));
 f.set("lissajous_e",random(-2,2));
 f.set("logapo_base",random(0.5,5));
 f.set("logdb_base",random(0.5,5));
 f.set("logdb_fix_period",random(0.3,3));
 f.set("loonie2_sides",(int)random(1,30));
 f.set("loonie2_star",random(-1,1));
 f.set("loonie2_circle",random(-1,1));
 f.set("loonie2_weight",random(0.8,1.6));
 f.set("loonie3_weight",random(0.8,1.6));
 f.set("mcarpet_x",random(-1,1));
 f.set("mcarpet_y",random(-1,1));
 f.set("mcarpet_tilt",random(-1,1));
 f.set("mcarpet_twist",random(-1,1));
 f.set("murl2_power",random(-3,3));
 f.set("murl2_c",random(-1,1));
 f.set("murl_power",random(-3,3));
 f.set("murl_c",random(-1,1));
 f.set("nblur_numedges",(int)random(3,20));
 f.set("nblur_numstripes",random(1)<0.5?0:(int)random(-30,30));
 // f.set("nblur_numstripes",0);
 f.set("nblur_ratiostripes",random(0,2));
 f.set("nblur_ratiohole",random(0,1));
 f.set("nblur_circumcircle",random(0,1)<0.5?1:0);
 f.set("nblur_adjusttolinear",random(0,1)<0.5?1:0);
 f.set("nblur_equalblur",random(0,1)<0.5?1:0);
 f.set("nblur_exactcalc",random(0,1)<0.5?1:0);
 f.set("nblur_highlightedges",random(0,2));
 f.set("nblur_weight",random(0.8,1.25));
 f.set("bsplit_shiftx",random(-2.0,2.0));
 f.set("bsplit_shifty",random(-2.0,2.0));
 f.set("devilwarp_a",random(-3,3));
 f.set("devilwarp_b",random(-3,3));
 f.set("devilwarp_effect",random(-2,2));
 f.set("devilwarp_warp",random(0.5,3));
 f.set("devilwarp_rmin",random(1));
 f.set("devilwarp_rmax",random(f.get("devilwarp_rmin")+random(0.5,1)));
 f.set("oscilloscope2_separation",random(0.01,2));
 f.set("oscilloscope2_frequencyx",random(-8,8));
 f.set("oscilloscope2_frequencyy",random(-8,8));
 f.set("oscilloscope2_amplitude",random(0.4,3));
 f.set("oscilloscope2_damping",random(0,1));
 f.set("oscilloscope2_perturbation",random(1));
 
 return f;
}

class Folds {
  int screenl, screenr;
  int middle;
  float ymin;
  float ymax;
  float xmin;
  float xmax;
  FloatDict params;
  
  String[] foldnames = { "none",
    "lines","flower","spherical","horseshoe","polar","spiral","hyperbolic","diamond","ex","julia","handkerchief",
    "disc","exponential","swirl","heart","power","eyefish","fisheye","bubble","square","cylinder","waves",
    "popcorn","sinusoidal","butterfly","cosine","rings","fan","blob","pdj","bent","fan2","rings2","perspective","vnoise",
    "julian","juliascope","blur","gaussian","realgaussian","radialblur","pie","ngon","curl","wedgejulia","circus","rectangles",
    "arch","tangent","rays","blade","secant","twintrian","cross","disc2","supershape","conic","parabola","bent2",
    "boarders","bipolar","cell","fold","foci","loonie","polar2","scry","vexp","rotate","curve","edisc", "elliptic",
    "escher", "lazysuzan", "modulus", "oscilloscope", "popcorn2", "separation", "split", "splits", "stripes", "wedge", "wedgesph",
    "whorl", "waves2", "auger", "flux", "mobius", "vlog", "vsin", "vcos", "vtan", "sec", "csc", "cot", "vsinh", "vcosh", "vtanh", "sech", "csch", "coth",
    "bcollide", "bmod", "bswirl", "btransform", "bwraps7", "barycentroid", "bilinear", "blocky", "blurzoom", "boarders2", "cannabiscurvewf",
    "checks", "circleblur", "circlecrop", "circlize", "cloverleaf", "collideoscope", "crackle", "crop", "dcperlin", "dlawf",
    "ecollide", "ejulia", /* brakowalo emod... do glynnsim3*/ "emod", "emotion", "epush", "erotate", "escale", "eswirl", "eclipse", "epispiral", "epispiralwf", "fibonacci2", "flipcircle",
    "flipy", "fourth", "gdoffs", "glynnsim1", "glynnsim2", "glynnsim3", "glynnia", "heartwf", "hexes", "hypertile1", "hypertile2", "hypertile",
    "jaccn", "jacdn", "jacsn", "juliac", "asteria", "bwrands", "circlize2", "ennepers", "funnel", "funnel2", "juliaq", "kaleidoscope","layeredspiral", "vibration2", "lazyjess",
    "lineart","lissajous","logapo","logdb","loonie2", "loonie3", "mcarpet","murl2","murl","nblur", "bsplit", "devilwarp", "oscilloscope2"};
    
  float lines_scale, lines_squared;
  float flower_petals, flower_holes;
  float waves_b, waves_e, waves_c, waves_f;
  float popcorn_c,popcorn_f;
  float rings_c, rings_c2;
  float fan_c, fan_f, fan_cc, fan_c2;
  float blob_low, blob_high, blob_waves, blob_bdiff;
  float pdj_a, pdj_b, pdj_c, pdj_d;
  float fan2_x, fan2_y, fan2_dx, fan2_dx2;
  float rings2_val, rings2_val2; 
  float perspective_angle, perspective_dist, perspective_vsin, perspective_vfcos;
  float julian_power, julian_dist, julian_cpower, julian_abspower;
  float juliascope_power, juliascope_dist, juliascope_cpower, juliascope_abspower;
  float radialblur_angle, radialblur_spinvar, radialblur_zoomvar;
  float pie_slices, pie_rotation, pie_thickness;
  float ngon_sides, ngon_power, ngon_circle, ngon_corners, ngon_pow, ngon_b;
  float curl_c1, curl_c2;
  float wedgejulia_count, wedgejulia_angle, wedgejulia_power, wedgejulia_dist, wedgejulia_cf, wedgejulia_cn, wedgejulia_rN;
  float circus_size;
  float rectangles_x, rectangles_y;
  float arch_weight;
  float rays_weight;
  float blade_weight;
  float secant_weight;
  float twintrian_weight;
  float disc2_rot, disc2_twist, disc2_timespi, disc2_sinadd, disc2_cosadd; 
  float supershape_rnd, supershape_m, supershape_n1, supershape_n2, supershape_n3, supershape_holes, supershape_pm_4, supershape_pneg1_n1;
  float conic_holes;
  float conic_eccentricity;  
  float parabola_width, parabola_height;
  float bent2_x, bent2_y;
  float bipolar_shift, bipolar_ps;  
  float cell_size;
  float cpow_r, cpow_i, cpow_power, cpow_va, cpow_vc, cpow_vd;
  float loonie_weight;
  float scry_weight;
  float curve_xamp, curve_yamp, curve_xlength, curve_ylength, curve_xlength2, curve_ylength2;
  float elliptic_v;
  float escher_beta, escher_vc, escher_vd;
  float lazysuzan_twist, lazysuzan_space, lazysuzan_spin, lazysuzan_x, lazysuzan_y, lazysuzan_weight;
  float modulus_x, modulus_y;
  float oscilloscope_separation, oscilloscope_frequency, oscilloscope_amplitude, oscilloscope_damping;
  float popcorn2_x, popcorn2_y, popcorn2_c;
  float separation_x, separation_y, separation_xinside, separation_yinside, separation_x2, separation_y2; 
  float split_xsize, split_ysize;
  float splits_x, splits_y;  
  float stripes_space, stripes_warp;
  float wedge_angle, wedge_hole, wedge_count, wedge_swirl;
  float wedgesph_angle, wedgesph_hole, wedgesph_count, wedgesph_swirl;
  float whorl_inside, whorl_outside, whorl_weight;
  float waves2_freqx, waves2_freqy, waves2_scalex, waves2_scaley;
  float auger_freq, auger_scale, auger_sym, auger_weight;
  float flux_spread, flux_weight;
  float mobius_re_a, mobius_im_a, mobius_re_b, mobius_im_b, mobius_re_c, mobius_im_c, mobius_re_d, mobius_im_d;
  float bcollide_num, bcollide_a, bcollide_bcn_pi, bcollide_pi_bcn, bcollide_bca_bcn;  
  float bmod_radius, bmod_distance;
  float bswirl_in, bswirl_out;
  float btransform_rotate, btransform_power, btransform_move, btransform_split;
  float bwraps7_cellsize, bwraps7_space, bwraps7_gain, bwraps7_inner_twist, bwraps7_outer_twist, bwraps7_g2, bwraps7_r2, bwraps7_rfactor;
  float barycentroid_a, barycentroid_b, barycentroid_c, barycentroid_d, barycentroid_dot00, barycentroid_dot01, barycentroid_dot11, barycentroid_invdenom;
  float blocky_x, blocky_y, blocky_mp, blocky_weight;
  float blurzoom_x, blurzoom_y, blurzoom_length;
  float boarders2_c, boarders2_left, boarders2_right, boarders2_cl, boarders2_cr;
  float cannabiscurvewf_filled;
  float checks_x, checks_y, checks_size, checks_rnd, checks_cs;
  float circlecrop_x, circlecrop_y, circlecrop_scatterarea, circlecrop_zero, circlecrop_radius;
  float circlize_hole;
  float cloverleaf_filled;
  float collideoscope_a, collideoscope_num, collideoscope_kn_pi, collideoscope_pi_kn, collideoscope_ka_kn;
  float crackle_cellsize, crackle_power, crackle_distort, crackle_scale, crackle_z;
  Crackle crackle_obj;
  float crop_left, crop_right, crop_top, crop_bottom, crop_scatter_area, crop_zero, crop_w, crop_h;
  float dcperlin_centre, dcperlin_range, dcperlin_notch_bottom, dcperlin_notch_top, dcperlin_shape, dcperlin_map, dcperlin_select_centre, dcperlin_select_range, dcperlin_edge, dcperlin_scale, dcperlin_octaves, dcperlin_freqs, dcperlin_z, dcperlin_select_bailout;
  float dlawf_buffersize, dlawf_maxiter, dlawf_seed, dlawf_scale;
  DLAWF dlawf_obj;
  float ecollide_num, ecollide_a, ecollide_ecn_pi, ecollide_pi_ecn, ecollide_eca_ecn;
  float ejulia_power;
  float emod_radius, emod_distance;
  float emotion_move, emotion_rotate;
  float epush_dist, epush_push, epush_rotate;
  float erotate_rotate;
  float escale_scale, escale_angle;
  float eswirl_in, eswirl_out;
  float eclipse_shift, eclipse_weight;
  float epispiral_n, epispiral_thickness, epispiral_holes;
  float epispiralwf_waves;
  float fibonacci2_sc, fibonacci2_sc2;
  float flipcircle_weight;
  float fourth_spin, fourth_space, fourth_twist, fourth_x, fourth_y, fourth_weight, fourth_sqrvvar;
  float gdoffs_delta_x, gdoffs_delta_y, gdoffs_area_x, gdoffs_area_y, gdoffs_center_x, gdoffs_center_y, gdoffs_gamma, gdoffs_square, gdoffs_gdodx, gdoffs_gdody, gdoffs_gdoax, gdoffs_gdoay, gdoffs_gdocx, gdoffs_gdocy, gdoffs_gdob;
  float glynnsim1_radius, glynnsim1_radius1, glynnsim1_phi1, glynnsim1_thickness, glynnsim1_pow, glynnsim1_contrast, glynnsim1_x1, glynnsim1_y1, glynnsim1_abspow;
  float glynnsim2_radius, glynnsim2_phi1, glynnsim2_phi2, glynnsim2_thickness, glynnsim2_pow, glynnsim2_contrast, glynnsim2_phi10, glynnsim2_phi20, glynnsim2_abspow, glynnsim2_gamma, glynnsim2_delta;
  float glynnsim3_radius, glynnsim3_thickness2, glynnsim3_thickness, glynnsim3_pow, glynnsim3_contrast, glynnsim3_abspow, glynnsim3_gamma, glynnsim3_radius1, glynnsim3_radius2;
  float heartwf_scale_x,heartwf_shift_t, heartwf_scale_t_left, heartwf_scale_t_right;    
  Hexes hexes_obj;  
  float hexes_cellsize, hexes_power, hexes_rotate, hexes_scale;  
  float hypertile1_pa, hypertile1_r, hypertile1_q, hypertile1_p;    
  float hypertile2_pa, hypertile2_r, hypertile2_q, hypertile2_p;    
  float hypertile_re, hypertile_im, hypertile_q, hypertile_p, hypertile_n;   
  float jaccn_k;
  float jacdn_k;
  float jacsn_k;
  float juliac_re, juliac_im, juliac_dist;
  float asteria_alpha, asteria_sina, asteria_cosa;
  float bwrands_cellsize, bwrands_space, bwrands_gain, bwrands_inner_twist, bwrands_outer_twist, bwrands_seed, bwrands_rrot, bwrands_rmin, bwrands_loonie_chance, bwrands_petals_chance, bwrands_minpetals, bwrands_maxpetals, bwrands_petx, bwrands_pety, bwrands_g2, bwrands_r2, bwrands_rfactor;
  float circlize2_hole;
  float funnel_effect;
  float funnel2_effect;
  float juliaq_power, juliaq_divisor, juliaq_half_inv_power, juliaq_inv_power, juliaq_inv_power_2pi;
  float kaleidoscope_pull, kaleidoscope_rotate, kaleidoscope_lineup, kaleidoscope_x, kaleidoscope_y;
  float layeredspiral_radius;
  float vibration2_dir,vibration2_angle,vibration2_freq,vibration2_amp,vibration2_phase,vibration2_dir2,vibration2_angle2,vibration2_freq2,vibration2_amp2,vibration2_phase2,vibration2_dm,vibration2_dmfreq,vibration2_tm,vibration2_tmfreq,vibration2_fm,vibration2_fmfreq,vibration2_am,vibration2_amfreq,vibration2_d2m,vibration2_d2mfreq,vibration2_t2m,vibration2_t2mfreq,vibration2_f2m,vibration2_f2mfreq,vibration2_a2m,vibration2_a2mfreq;
  float lazyjess_n, lazyjess_spin, lazyjess_space, lazyjess_corner, lazyjess_vertex, lazyjess_sin_vertex, lazyjess_pie_slice, lazyjess_half_slice, lazyjess_corner_rotation, lazyjess_weight;
  float lineart_powx, lineart_powy;   
  float lissajous_tmin, lissajous_tmax, lissajous_a, lissajous_b, lissajous_c, lissajous_d, lissajous_e;   
  float logapo_base, logapo_denom;   
  float logdb_base, logdb_fix_period, logdb_denom, logdb_fixpe;   
  float loonie2_sides, loonie2_star, loonie2_circle, loonie2_weight, loonie2_sqrvvar, loonie2_sina, loonie2_cosa, loonie2_sins, loonie2_coss, loonie2_sinc, loonie2_cosc;   
  float loonie3_weight, loonie3_sqrvvar;   
  float mcarpet_x, mcarpet_y, mcarpet_twist, mcarpet_tilt;   
  float murl2_power, murl2_c;   
  float murl_power, murl_c; 
  float nblur_numedges, nblur_numstripes, nblur_ratiostripes, nblur_ratiohole, nblur_circumcircle, nblur_adjusttolinear, nblur_equalblur, nblur_exactcalc, nblur_highlightedges;
  float nblur_weight, nblur_midAngle, nblur_angStripes, nblur_angStart, nblur_ratiocomplement, nblur_tan90_m_2, nblur_sina, nblur_cosa,  nblur_speedCalc1, nblur_speedCalc2, nblur_maxStripes, nblur_arc_tan1, nblur_arc_tan2;
  int nblur_hasStripes, nblur_negStripes;
  float bsplit_shiftx, bsplit_shifty;
  float devilwarp_a, devilwarp_b, devilwarp_effect, devilwarp_warp, devilwarp_rmin, devilwarp_rmax;
  float oscilloscope2_separation, oscilloscope2_frequencyx, oscilloscope2_frequencyy, oscilloscope2_amplitude, oscilloscope2_damping, oscilloscope2_perturbation;

  Folds(int _size,float _ymin,float _ymax,float _xmin,float _xmax) {
    float middle = _size/2;
    float size = 0.95 * middle;
    screenl = (int)(-size + middle);
    screenr =(int)(size + middle);
    ymin = _ymin;
    ymax = _ymax;
    xmin = _xmin;
    xmax = _xmax;
    
    setParameters(getFoldsParameters());
  }
    
  void setParameters(FloatDict p) {
    params = p;
    
lines_scale             = p.get("lines_scale");
lines_squared           = p.get("lines_squared");
flower_petals           = p.get("flower_petals");
flower_holes            = p.get("flower_holes");
waves_b                 = p.get("waves_b");
waves_e                 = p.get("waves_e");
waves_c                 = p.get("waves_c");
waves_f                 = p.get("waves_f");
popcorn_c               = p.get("popcorn_c");
popcorn_f               = p.get("popcorn_f");
rings_c                 = p.get("rings_c");
fan_c                   = p.get("fan_c");
fan_f                   = p.get("fan_f");
blob_low                = p.get("blob_low");
blob_high               = p.get("blob_high");
blob_waves              = p.get("blob_waves");
pdj_a                   = p.get("pdj_a");
pdj_b                   = p.get("pdj_b");
pdj_c                   = p.get("pdj_c");
pdj_d                   = p.get("pdj_d");
fan2_x                  = p.get("fan2_x");
fan2_y                  = p.get("fan2_y");
rings2_val              = p.get("rings2_val");
perspective_angle       = p.get("perspective_angle");
perspective_dist        = p.get("perspective_dist");
julian_power            = p.get("julian_power");
julian_dist             = p.get("julian_dist");
juliascope_power        = p.get("juliascope_power");
juliascope_dist         = p.get("juliascope_dist");
radialblur_angle        = p.get("radialblur_angle");
pie_slices              = p.get("pie_slices");
pie_rotation            = p.get("pie_rotation");
pie_thickness           = p.get("pie_thickness");
ngon_sides              = p.get("ngon_sides");
ngon_power              = p.get("ngon_power");
ngon_circle             = p.get("ngon_circle");
ngon_corners            = p.get("ngon_corners");
curl_c1                 = p.get("curl_c1");
curl_c2                 = p.get("curl_c2");
wedgejulia_count        = p.get("wedgejulia_count");
wedgejulia_angle        = p.get("wedgejulia_angle");
wedgejulia_power        = p.get("wedgejulia_power");
wedgejulia_dist         = p.get("wedgejulia_dist");
circus_size             = p.get("circus_size");
rectangles_x            = p.get("rectangles_x");
rectangles_y            = p.get("rectangles_y");
arch_weight             = p.get("arch_weight");
rays_weight             = p.get("rays_weight");
blade_weight            = p.get("blade_weight");
secant_weight           = p.get("secant_weight");
twintrian_weight        = p.get("twintrian_weight");
disc2_rot               = p.get("disc2_rot");
disc2_twist             = p.get("disc2_twist");
supershape_rnd          = p.get("supershape_rnd");
supershape_m            = p.get("supershape_m");
supershape_n1           = p.get("supershape_n1");
supershape_n2           = p.get("supershape_n2");
supershape_n3           = p.get("supershape_n3");
supershape_holes        = p.get("supershape_holes");
conic_holes             = p.get("conic_holes");
conic_eccentricity      = p.get("conic_eccentricity");
parabola_width          = p.get("parabola_width");
parabola_height         = p.get("parabola_height");
bent2_x                 = p.get("bent2_x");
bent2_y                 = p.get("bent2_y");
bipolar_shift           = p.get("bipolar_shift");
cell_size               = p.get("cell_size");
cpow_r                  = p.get("cpow_r");
cpow_i                  = p.get("cpow_i");
cpow_power              = p.get("cpow_power");
loonie_weight           = p.get("loonie_weight");
scry_weight             = p.get("scry_weight");
curve_xamp              = p.get("curve_xamp");
curve_yamp              = p.get("curve_yamp");
curve_xlength           = p.get("curve_xlength");    
curve_ylength           = p.get("curve_ylength");
escher_beta             = p.get("escher_beta");
lazysuzan_spin          = p.get("lazysuzan_spin");
lazysuzan_twist         = p.get("lazysuzan_twist");
lazysuzan_space         = p.get("lazysuzan_space");
lazysuzan_x             = p.get("lazysuzan_x");
lazysuzan_y             = p.get("lazysuzan_y");
lazysuzan_weight        = p.get("lazysuzan_weight");
modulus_x               = p.get("modulus_x");
modulus_y               = p.get("modulus_y");
oscilloscope_separation = p.get("oscilloscope_separation");
oscilloscope_frequency  = p.get("oscilloscope_frequency");
oscilloscope_amplitude  = p.get("oscilloscope_amplitude");
oscilloscope_damping    = p.get("oscilloscope_damping");
popcorn2_x              = p.get("popcorn2_x");
popcorn2_y              = p.get("popcorn2_y");
popcorn2_c              = p.get("popcorn2_c");
separation_x            = p.get("separation_x");
separation_y            = p.get("separation_y");
separation_xinside      = p.get("separation_xinside");
separation_yinside      = p.get("separation_yinside");
split_xsize             = p.get("split_xsize");
split_ysize             = p.get("split_ysize");
splits_x                = p.get("splits_x");
splits_y                = p.get("splits_y");
stripes_space           = p.get("stripes_space");
stripes_warp            = p.get("stripes_warp");
wedge_angle             = p.get("wedge_angle");
wedge_hole              = p.get("wedge_hole");
wedge_count             = p.get("wedge_count");
wedge_swirl             = p.get("wedge_swirl");
wedgesph_angle          = p.get("wedge_angle");
wedgesph_hole           = p.get("wedge_hole");
wedgesph_count          = p.get("wedge_count");
wedgesph_swirl          = p.get("wedge_swirl");
whorl_inside            = p.get("whorl_inside");
whorl_outside           = p.get("whorl_outside");
whorl_weight            = p.get("whorl_weight");
waves2_freqx            = p.get("waves2_freqx");
waves2_freqy            = p.get("waves2_freqy");
waves2_scalex           = p.get("waves2_scalex");
waves2_scaley           = p.get("waves2_scaley");
auger_freq              = p.get("auger_freq");
auger_scale             = p.get("auger_scale");
auger_sym               = p.get("auger_sym");
auger_weight            = p.get("auger_weight");
flux_spread             = p.get("flux_spread");
flux_weight             = p.get("flux_weight");
mobius_re_a             = p.get("mobius_re_a");
mobius_im_a             = p.get("mobius_im_a");
mobius_re_b             = p.get("mobius_re_b");
mobius_im_b             = p.get("mobius_im_b");
mobius_re_c             = p.get("mobius_re_c");
mobius_im_c             = p.get("mobius_im_c");
mobius_re_d             = p.get("mobius_re_d");
mobius_im_d             = p.get("mobius_im_d");
bcollide_num            = p.get("bcollide_num");
bcollide_a              = p.get("bcollide_a");
bmod_radius             = p.get("bmod_radius");
bmod_distance           = p.get("bmod_distance");
bswirl_in               = p.get("bswirl_in");
bswirl_out              = p.get("bswirl_out");
btransform_rotate       = p.get("btransform_rotate");
btransform_power        = p.get("btransform_power");
btransform_move         = p.get("btransform_move");
btransform_split        = p.get("btransform_split");
bwraps7_cellsize        = p.get("bwraps7_cellsize");
bwraps7_space           = p.get("bwraps7_space");
bwraps7_gain            = p.get("bwraps7_gain");
bwraps7_inner_twist     = p.get("bwraps7_inner_twist");
bwraps7_outer_twist     = p.get("bwraps7_outer_twist");
barycentroid_a          = p.get("barycentroid_a");
barycentroid_b          = p.get("barycentroid_b");
barycentroid_c          = p.get("barycentroid_c");
barycentroid_d          = p.get("barycentroid_d");
blocky_x                = p.get("blocky_x");
blocky_y                = p.get("blocky_y");
blocky_mp               = p.get("blocky_mp");
blocky_weight           = p.get("blocky_weight");
blurzoom_x              = p.get("blurzoom_x");
blurzoom_y              = p.get("blurzoom_y");
blurzoom_length         = p.get("blurzoom_length");
boarders2_c             = p.get("boarders2_c");
boarders2_left          = p.get("boarders2_left");
boarders2_right         = p.get("boarders2_right");
cannabiscurvewf_filled  = p.get("cannabiscurvewf_filled");
checks_x                = p.get("checks_x");
checks_y                = p.get("checks_y");
checks_size             = p.get("checks_size");
checks_rnd              = p.get("checks_rnd");
circlecrop_x            = p.get("circlecrop_x");
circlecrop_y            = p.get("circlecrop_y");
circlecrop_scatterarea  = p.get("circlecrop_scatterarea");
circlecrop_zero         = p.get("circlecrop_zero");
circlecrop_radius       = p.get("circlecrop_radius");
circlize_hole           = p.get("circlize_hole");
cloverleaf_filled       = p.get("cloverleaf_filled");
collideoscope_a         = p.get("collideoscope_a");
collideoscope_num       = p.get("collideoscope_num");
crackle_cellsize        = p.get("crackle_cellsize");
crackle_distort         = p.get("crackle_distort");
crackle_power           = p.get("crackle_power");
crackle_scale           = p.get("crackle_scale");
crackle_z               = p.get("crackle_z");
crop_left               = p.get("crop_left");
crop_bottom             = p.get("crop_bottom");
crop_right              = p.get("crop_right");
crop_top                = p.get("crop_top");
crop_scatter_area       = p.get("crop_scatter_area");
crop_zero               = p.get("crop_zero");
dcperlin_edge           = p.get("dcperlin_edge");
dcperlin_freqs          = p.get("dcperlin_freqs");
dcperlin_map            = p.get("dcperlin_map");
dcperlin_octaves        = p.get("dcperlin_octaves");
dcperlin_scale          = p.get("dcperlin_scale");
dcperlin_select_bailout = p.get("dcperlin_select_bailout");
dcperlin_select_centre  = p.get("dcperlin_select_centre");
dcperlin_select_range   = p.get("dcperlin_select_range");
dcperlin_shape          = p.get("dcperlin_shape");
dcperlin_z              = p.get("dcperlin_z");
dcperlin_centre         = p.get("dcperlin_centre");
dcperlin_range          = p.get("dcperlin_range");
dlawf_buffersize        = p.get("dlawf_buffersize");
dlawf_maxiter           = p.get("dlawf_maxiter");
dlawf_seed              = p.get("dlawf_seed");
dlawf_scale             = p.get("dlawf_scale");
ecollide_a              = p.get("ecollide_a");
ecollide_num            = p.get("ecollide_num");
ejulia_power            = p.get("ejulia_power");
emod_distance           = p.get("emod_distance");
emod_radius             = p.get("emod_radius");
emotion_move            = p.get("emotion_move");
emotion_rotate          = p.get("emotion_rotate");
epush_dist              = p.get("epush_dist");
epush_push              = p.get("epush_push");
epush_rotate            = p.get("epush_rotate");
erotate_rotate          = p.get("erotate_rotate");
escale_angle            = p.get("escale_angle");
escale_scale            = p.get("escale_scale");
eswirl_in               = p.get("eswirl_in");
eswirl_out              = p.get("eswirl_out");
eclipse_shift           = p.get("eclipse_shift");
eclipse_weight          = p.get("eclipse_weight");
epispiral_n             = p.get("epispiral_n");
epispiral_holes         = p.get("epispiral_holes");
epispiral_thickness     = p.get("epispiral_thickness");
epispiralwf_waves       = p.get("epispiralwf_waves");
fibonacci2_sc           = p.get("fibonacci2_sc");
fibonacci2_sc2          = p.get("fibonacci2_sc2");
flipcircle_weight       = p.get("flipcircle_weight");
fourth_spin             = p.get("fourth_spin");
fourth_space            = p.get("fourth_space");
fourth_twist            = p.get("fourth_twist");
fourth_x                = p.get("fourth_x");
fourth_y                = p.get("fourth_y");
fourth_weight           = p.get("fourth_weight");
gdoffs_delta_x          = p.get("gdoffs_delta_x");
gdoffs_delta_y          = p.get("gdoffs_delta_y");
gdoffs_area_x           = p.get("gdoffs_area_x");
gdoffs_area_y           = p.get("gdoffs_area_y");
gdoffs_center_x         = p.get("gdoffs_center_x");
gdoffs_center_y         = p.get("gdoffs_center_y");
gdoffs_gamma            = p.get("gdoffs_gamma");
gdoffs_square           = p.get("gdoffs_square");
glynnsim1_radius        = p.get("glynnsim1_radius");
glynnsim1_radius1       = p.get("glynnsim1_radius1");
glynnsim1_phi1          = p.get("glynnsim1_phi1");
glynnsim1_thickness     = p.get("glynnsim1_thickness");
glynnsim1_pow           = p.get("glynnsim1_pow");
glynnsim1_contrast      = p.get("glynnsim1_contrast");
glynnsim2_radius        = p.get("glynnsim2_radius");
glynnsim2_phi2          = p.get("glynnsim2_phi2");
glynnsim2_phi1          = p.get("glynnsim2_phi1");
glynnsim2_thickness     = p.get("glynnsim2_thickness");
glynnsim2_pow           = p.get("glynnsim2_pow");
glynnsim2_contrast      = p.get("glynnsim2_contrast");
glynnsim3_radius        = p.get("glynnsim3_radius");
glynnsim3_thickness2    = p.get("glynnsim3_thickness2");
glynnsim3_thickness     = p.get("glynnsim3_thickness");
glynnsim3_pow           = p.get("glynnsim3_pow");
glynnsim3_contrast      = p.get("glynnsim3_contrast");
heartwf_scale_t_left    = p.get("heartwf_scale_t_left");
heartwf_scale_t_right   = p.get("heartwf_scale_t_right");
heartwf_scale_x         = p.get("heartwf_scale_x");
heartwf_shift_t         = p.get("heartwf_shift_t");
hexes_cellsize          = p.get("hexes_cellsize");
hexes_power             = p.get("hexes_power");
hexes_rotate            = p.get("hexes_rotate");
hexes_scale             = p.get("hexes_scale");
hypertile1_p            = p.get("hypertile1_p");
hypertile1_q            = p.get("hypertile1_q");
hypertile2_p            = p.get("hypertile2_p");
hypertile2_q            = p.get("hypertile2_q");
hypertile_q             = p.get("hypertile_q");
hypertile_p             = p.get("hypertile_p");
hypertile_n             = p.get("hypertile_n");
jaccn_k                 = p.get("jaccn_k");
jacdn_k                 = p.get("jacdn_k");
jacsn_k                 = p.get("jacsn_k");
juliac_dist             = p.get("juliac_dist");
juliac_im               = p.get("juliac_im");
juliac_re               = p.get("juliac_re");
asteria_alpha           = p.get("asteria_alpha");
bwrands_cellsize        = p.get("bwrands_cellsize");
bwrands_space           = p.get("bwrands_space");
bwrands_gain            = p.get("bwrands_gain");
bwrands_inner_twist     = p.get("bwrands_inner_twist");
bwrands_outer_twist     = p.get("bwrands_outer_twist");
bwrands_seed            = p.get("bwrands_seed");
bwrands_rrot            = p.get("bwrands_rrot");
bwrands_rmin            = p.get("bwrands_rmin");
bwrands_loonie_chance   = p.get("bwrands_loonie_chance");
bwrands_petals_chance   = p.get("bwrands_petals_chance");
bwrands_minpetals       = p.get("bwrands_minpetals");
bwrands_maxpetals       = p.get("bwrands_maxpetals");
circlize2_hole          = p.get("circlize2_hole");
funnel_effect           = p.get("funnel_effect");
funnel2_effect          = p.get("funnel2_effect");
juliaq_power            = p.get("juliaq_power");
juliaq_divisor          = p.get("juliaq_divisor");
kaleidoscope_pull       = p.get("kaleidoscope_pull");
kaleidoscope_rotate     = p.get("kaleidoscope_rotate");
kaleidoscope_lineup     = p.get("kaleidoscope_lineup");
kaleidoscope_x          = p.get("kaleidoscope_x");
kaleidoscope_y          = p.get("kaleidoscope_y");
layeredspiral_radius    = p.get("layeredspiral_radius");
vibration2_dir          = p.get("vibration2_dir");
vibration2_angle        = p.get("vibration2_angle");
vibration2_freq         = p.get("vibration2_freq");
vibration2_amp          = p.get("vibration2_amp");
vibration2_phase        = p.get("vibration2_phase");
vibration2_dir2         = p.get("vibration2_dir2");
vibration2_angle2       = p.get("vibration2_angle2");
vibration2_freq2        = p.get("vibration2_freq2");
vibration2_amp2         = p.get("vibration2_amp2");
vibration2_phase2       = p.get("vibration2_phase2");
vibration2_dm           = p.get("vibration2_dm");
vibration2_dmfreq       = p.get("vibration2_dmfreq");
vibration2_tm           = p.get("vibration2_tm");
vibration2_tmfreq       = p.get("vibration2_tmfreq");
vibration2_fm           = p.get("vibration2_fm");
vibration2_fmfreq       = p.get("vibration2_fmfreq");
vibration2_am           = p.get("vibration2_am");
vibration2_amfreq       = p.get("vibration2_amfreq");
vibration2_d2m          = p.get("vibration2_d2m");
vibration2_d2mfreq      = p.get("vibration2_d2mfreq");
vibration2_t2m          = p.get("vibration2_t2m");
vibration2_t2mfreq      = p.get("vibration2_t2mfreq");
vibration2_f2m          = p.get("vibration2_f2m");
vibration2_f2mfreq      = p.get("vibration2_f2mfreq");
vibration2_a2m          = p.get("vibration2_a2m");
vibration2_a2mfreq      = p.get("vibration2_a2mfreq");
lazyjess_n              = p.get("lazyjess_n");
lazyjess_spin           = p.get("lazyjess_spin");
lazyjess_space          = p.get("lazyjess_space");
lazyjess_corner         = p.get("lazyjess_corner");
lazyjess_weight         = p.get("lazyjess_weight");
lineart_powx            = p.get("lineart_powx");
lineart_powy            = p.get("lineart_powy");
lissajous_tmin          = p.get("lissajous_tmin");
lissajous_tmax          = p.get("lissajous_tmax");
lissajous_a             = p.get("lissajous_a");
lissajous_b             = p.get("lissajous_b");
lissajous_c             = p.get("lissajous_c");
lissajous_d             = p.get("lissajous_d");
lissajous_e             = p.get("lissajous_e");
logapo_base             = p.get("logapo_base");
logdb_base              = p.get("logdb_base");
logdb_fix_period        = p.get("logdb_fix_period");
loonie2_sides           = p.get("loonie2_sides");
loonie2_star            = p.get("loonie2_star");
loonie2_circle          = p.get("loonie2_circle");
loonie2_weight          = p.get("loonie2_weight");
loonie3_weight          = p.get("loonie3_weight");
mcarpet_x               = p.get("mcarpet_x");
mcarpet_y               = p.get("mcarpet_y");
mcarpet_tilt            = p.get("mcarpet_tilt");
mcarpet_twist           = p.get("mcarpet_twist");
murl2_power             = p.get("murl2_power");
murl2_c                 = p.get("murl2_c");
murl_power              = p.get("murl_power");
murl_c                  = p.get("murl_c");
nblur_numedges          = p.get("nblur_numedges");
nblur_numstripes        = p.get("nblur_numstripes");
nblur_ratiostripes      = p.get("nblur_ratiostripes");
nblur_ratiohole         = p.get("nblur_ratiohole");
nblur_circumcircle      = p.get("nblur_circumcircle");
nblur_adjusttolinear    = p.get("nblur_adjusttolinear");
nblur_equalblur         = p.get("nblur_equalblur");
nblur_exactcalc         = p.get("nblur_exactcalc");
nblur_highlightedges    = p.get("nblur_highlightedges");
nblur_weight            = p.get("nblur_weight");
bsplit_shiftx           = p.get("bsplit_shiftx");
bsplit_shifty           = p.get("bsplit_shifty");
devilwarp_a = p.get("devilwarp_a");
devilwarp_b = p.get("devilwarp_b");
devilwarp_effect = p.get("devilwarp_effect");
devilwarp_rmax = p.get("devilwarp_rmax");
devilwarp_rmin = p.get("devilwarp_rmin");
devilwarp_warp = p.get("devilwarp_warp");
oscilloscope2_separation = p.get("oscilloscope2_separation");
oscilloscope2_frequencyx  = p.get("oscilloscope2_frequencyx");
oscilloscope2_frequencyy  = p.get("oscilloscope2_frequencyy");
oscilloscope2_amplitude  = p.get("oscilloscope2_amplitude");
oscilloscope2_damping    = p.get("oscilloscope2_damping");
oscilloscope2_perturbation  = p.get("oscilloscope2_perturbation");

    precalc();

  }
  
  PVector getFoldbyNo(int no, PVector p, float w) {
    switch(no) {
      case 1: return lines(p,w);
      case 2: return flower(p,w);
      case 3: return spherical(p,w);
      case 4: return horseshoe(p,w);
      case 5: return polar(p,w);
      case 6: return spiral(p,w);
      case 7: return hyperbolic(p,w);
      case 8: return diamond(p,w);
      case 9: return ex(p,w);
      case 10: return julia(p,w);
      case 11: return handkerchief(p,w);
      case 12: return disc(p,w);
      case 13: return exponential(p,w);
      case 14: return swirl(p,w);
      case 15: return heart(p,w);
      case 16: return power(p,w);
      case 17: return eyefish(p,w);
      case 18: return fisheye(p,w);
      case 19: return bubble(p,w);
      case 20: return square(p,w);
      case 21: return cylinder(p,w);
      case 22: return waves(p,w);
      case 23: return popcorn(p,w);
      case 24: return sinusoidal(p,w);
      case 25: return butterfly(p,w);
      case 26: return cosine(p,w);
      case 27: return rings(p,w);
      case 28: return fan(p,w);
      case 29: return blob(p,w);
      case 30: return pdj(p,w);
      case 31: return bent(p,w);
      case 32: return fan2(p,w);
      case 33: return rings2(p,w);
      case 34: return perspective(p,w);
      case 35: return vnoise(p,w);
      case 36: return julian(p,w);
      case 37: return juliascope(p,w);
      case 38: return blur(p,w);
      case 39: return gaussian(p,w);
      case 40: return realgaussian(p,w);
      case 41: return radialblur(p,w);
      case 42: return pie(p,w);
      case 43: return ngon(p,w);
      case 44: return curl(p,w);
      case 45: return wedgejulia(p,w);
      case 46: return circus(p,w);
      case 47: return rectangles(p,w);
      case 48: return arch(p,w);
      case 49: return tangent(p,w);
      case 50: return rays(p,w);
      case 51: return blade(p,w);
      case 52: return secant(p,w);
      case 53: return twintrian(p,w);
      case 54: return cross(p,w);
      case 55: return disc2(p,w);
      case 56: return supershape(p,w);
      case 57: return conic(p,w);
      case 58: return parabola(p,w);
      case 59: return bent2(p,w);
      case 60: return boarders(p,w);
      case 61: return bipolar(p,w);
      case 62: return cell(p,w);
      case 63: return fold(p,w);
      case 64: return foci(p,w);
      case 65: return loonie(p,w);
      case 66: return polar2(p,w);
      case 67: return scry(p,w);
      case 68: return vexp(p,w);
      case 69: return rotate(p,w);
      case 70: return curve(p,w);
      case 71: return edisc(p,w);
      case 72: return elliptic(p,w);
      case 73: return escher(p,w);
      case 74: return lazysuzan(p,w);
      case 75: return modulus(p,w);
      case 76: return oscilloscope(p,w);
      case 77: return popcorn2(p,w);
      case 78: return separation(p,w);
      case 79: return split(p,w);
      case 80: return splits(p,w);
      case 81: return stripes(p,w);
      case 82: return wedge(p,w);
      case 83: return wedgesph(p,w);
      case 84: return whorl(p,w);
      case 85: return waves2(p,w);
      case 86: return auger(p,w);
      case 87: return flux(p,w);
      case 88: return mobius(p,w);
      case 89: return vlog(p,w);
      case 90: return vsin(p,w);
      case 91: return vcos(p,w);
      case 92: return vtan(p,w);
      case 93: return sec(p,w);
      case 94: return csc(p,w);
      case 95: return cot(p,w);
      case 96: return vsinh(p,w);
      case 97: return vcosh(p,w);
      case 98: return vtanh(p,w);
      case 99: return sech(p,w);
      case 100: return csch(p,w);
      case 101: return coth(p,w); 
      case 102: return bcollide(p,w);
      case 103: return bmod(p,w);
      case 104: return bswirl(p,w);
      case 105: return btransform(p,w);
      case 106: return bwraps7(p,w);
      case 107: return barycentroid(p,w);
      case 108: return bilinear(p,w);
      case 109: return blocky(p,w);
      case 110: return blurzoom(p,w);
      case 111: return boarders2(p,w);
      case 112: return cannabiscurvewf(p,w);
      case 113: return checks(p,w);
      case 114: return circleblur(p,w);
      case 115: return circlecrop(p,w);
      case 116: return circlize(p,w);
      case 117: return cloverleaf(p,w);
      case 118: return collideoscope(p,w);
      case 119: return crackle(p,w);
      case 120: return crop(p,w);
      case 121: return dcperlin(p,w);
      case 122: return dlawf(p,w);
      case 123: return ecollide(p,w);
      case 124: return ejulia(p,w);
      case 125: return emod(p,w);
      case 126: return emotion(p,w);
      case 127: return epush(p,w);
      case 128: return erotate(p,w);
      case 129: return escale(p,w);
      case 130: return eswirl(p,w);
      case 131: return eclipse(p,w);
      case 132: return epispiral(p,w);
      case 133: return epispiralwf(p,w);
      case 134: return fibonacci2(p,w);
      case 135: return flipcircle(p,w);
      case 136: return flipy(p,w);
      case 137: return fourth(p,w);
      case 138: return gdoffs(p,w);
      case 139: return glynnsim1(p,w);
      case 140: return glynnsim2(p,w);
      case 141: return glynnsim3(p,w);
      case 142: return glynnia(p,w);
      case 143: return heartwf(p,w);
      case 144: return hexes(p,w);
      case 145: return hypertile1(p,w);
      case 146: return hypertile2(p,w);
      case 147: return hypertile(p,w);
      case 148: return jaccn(p,w);
      case 149: return jacdn(p,w);
      case 150: return jacsn(p,w);
      case 151: return juliac(p,w);
      case 152: return asteria(p,w);
      case 153: return bwrands(p,w);
      case 154: return circlize2(p,w);
      case 155: return ennepers(p,w);
      case 156: return funnel(p,w);
      case 157: return funnel2(p,w);
      case 158: return juliaq(p,w);
      case 159: return kaleidoscope(p,w);
      case 160: return layeredspiral(p,w);
      case 161: return vibration2(p,w);
      case 162: return lazyjess(p,w);
      case 163: return lineart(p,w);
      case 164: return lissajous(p,w);
      case 165: return logapo(p,w);
      case 166: return logdb(p,w);
      case 167: return loonie2(p,w);
      case 168: return loonie3(p,w);
      case 169: return mcarpet(p,w);
      case 170: return murl2(p,w);
      case 171: return murl(p,w);
      case 172: return nblur(p,w);
      case 173: return bsplit(p,w);
      case 174: return devilwarp(p,w);
      case 175: return oscilloscope2(p,w);
      default: return new PVector(w * p.x, w * p.y);
    }
  }  
  
  void precalc() {
    float tmp, tmp2;
    
    rings_c2 = rings_c * rings_c;
    
    fan_cc = PI * sq(fan_c);
    fan_c2 = 0.5 * fan_cc;
    
    blob_bdiff = blob_high - blob_low;
    
    fan2_dx = PI * sq(fan2_x) + 1.0e-10;
    fan2_dx2 = 0.5 * fan2_dx;
    
    rings2_val2 = sq(rings2_val);
    
    tmp = perspective_angle * PI/2.0;
    perspective_vsin = sin(tmp);
    perspective_vfcos = perspective_dist * cos(tmp);
    
    julian_cpower = julian_dist/julian_power/2.0;
    julian_abspower = abs(julian_power);
    
    juliascope_cpower = juliascope_dist/juliascope_power/2.0;
    juliascope_abspower = abs(juliascope_power);
    
    radialblur_spinvar = sin(radialblur_angle);
    radialblur_zoomvar = cos(radialblur_angle);
    
    ngon_pow = ngon_power/2.0;
    ngon_b = TWO_PI / ngon_sides;
    
    wedgejulia_cf = 1.0 - 0.5 / PI * wedgejulia_angle * wedgejulia_count;
    wedgejulia_cn = wedgejulia_dist / wedgejulia_power / 2.0;
    wedgejulia_rN = abs(wedgejulia_power);
    
    disc2_timespi = disc2_rot * PI;
    disc2_sinadd = sin(disc2_twist);
    disc2_cosadd = cos(disc2_twist)-1.0;
    if(disc2_twist > TWO_PI) {
      float k = 1 + disc2_twist - TWO_PI;
      disc2_cosadd *= k;
      disc2_sinadd *= k;
    }
    if(disc2_twist < -TWO_PI) {
      float k = 1 + disc2_twist + TWO_PI;
      disc2_cosadd *= k;
      disc2_sinadd *= k;
    }
    
    supershape_pm_4 = supershape_m / 4.0;
    supershape_pneg1_n1 = -1.0 / supershape_n1;
    
    bipolar_ps = -HALF_PI * bipolar_shift;
    
    cpow_va = TWO_PI / cpow_power;
    cpow_vc = cpow_r / cpow_power;
    cpow_vd = cpow_i / cpow_power;
    
    curve_xlength2 = sq(curve_xlength);
    curve_ylength2 = sq(curve_ylength);
    
    elliptic_v =  2 / HALF_PI;
    
    escher_vc = 0.5 * (1.0 + cos(escher_beta));
    escher_vd = 0.5 * sin(escher_beta);
    
    separation_x2 = sq(separation_x);
    separation_y2 = sq(separation_y);
    
    bcollide_bcn_pi = bcollide_num / PI;
    bcollide_pi_bcn = PI / bcollide_num;
    bcollide_bca_bcn = (PI * bcollide_a) / bcollide_num;
    
    tmp = 0.5 * (bwraps7_cellsize / (1.0 + sq(bwraps7_space)));
    bwraps7_g2 = sq(bwraps7_gain) + 1.0e-10;
    tmp2 = bwraps7_g2 * tmp;
    if(tmp2>2.0) 
      tmp2 = 1.0;
     else
      tmp2 *= 1.0 / (( sq(tmp2) / 4.0 + 1.0));
    bwraps7_r2 = sq(tmp);
    bwraps7_rfactor = tmp / tmp2;  
    
    barycentroid_dot00 = sq(barycentroid_a) + sq(barycentroid_b);
    barycentroid_dot01 = barycentroid_a * barycentroid_c + barycentroid_b * barycentroid_d;
    barycentroid_dot11 = sq(barycentroid_c) + sq(barycentroid_d);
    barycentroid_invdenom = 1.0 / (barycentroid_dot00 * barycentroid_dot11 - sq(barycentroid_dot01));
    
    boarders2_cl = boarders2_c * boarders2_left;
    boarders2_cr = boarders2_c + (boarders2_c * boarders2_right);
    
    checks_cs = 1.0 / (checks_size + 1.0e-10);
    
    collideoscope_kn_pi = collideoscope_num / PI;
    collideoscope_pi_kn = PI / collideoscope_num;
    collideoscope_ka_kn = (PI * collideoscope_a) / collideoscope_num;
    
    crackle_obj = new Crackle(crackle_z, crackle_cellsize, crackle_distort, crackle_power, crackle_scale);
    
    crop_w = (crop_right - crop_left) * 0.5 * crop_scatter_area;
    crop_h = (crop_bottom - crop_top) * 0.5 * crop_scatter_area;
    
    dcperlin_notch_bottom = dcperlin_select_centre - dcperlin_select_range;
    dcperlin_notch_bottom = (dcperlin_notch_bottom > 0.75) ? 0.75 : dcperlin_notch_bottom;
    dcperlin_notch_bottom = (dcperlin_notch_bottom < -3.0) ? -3.0 : dcperlin_notch_bottom;
    dcperlin_notch_top = dcperlin_select_centre + dcperlin_select_range;
    dcperlin_notch_top = (dcperlin_notch_top < -0.75) ? -0.75 : dcperlin_notch_top;
    dcperlin_notch_top = (dcperlin_notch_top > 3.0) ? 3.0 : dcperlin_notch_top;
    
    dlawf_obj = new DLAWF(dlawf_seed, dlawf_maxiter, dlawf_buffersize, dlawf_scale);
    
    ecollide_ecn_pi = ecollide_num / PI;
    ecollide_pi_ecn = PI / ecollide_num;
    ecollide_eca_ecn = (PI * ecollide_a) / ecollide_num;
    
    fourth_sqrvvar = sq(fourth_weight);
    
    gdoffs_gdodx = gdoffs_delta_x * gdoffs_agdod;
    gdoffs_gdody = gdoffs_delta_y * gdoffs_agdod;
    gdoffs_gdoax = (abs(gdoffs_area_x) < 0.1 ? 0.1 : abs(gdoffs_area_x)) * gdoffs_agdoa;
    gdoffs_gdoay = (abs(gdoffs_area_y) < 0.1 ? 0.1 : abs(gdoffs_area_y)) * gdoffs_agdoa;
    gdoffs_gdocx = gdoffs_center_x * gdoffs_agdoc;
    gdoffs_gdocy = gdoffs_center_y * gdoffs_agdoc;
    gdoffs_gdob = gdoffs_gamma * gdoffs_agdoa / (max(gdoffs_gdoax, gdoffs_gdoay));
    
    tmp = PI * glynnsim1_phi1 / 180.0;
    glynnsim1_x1 = glynnsim1_radius * cos(tmp);
    glynnsim1_y1 = glynnsim1_radius * sin(tmp);
    glynnsim1_abspow = abs(glynnsim1_pow); 
    
    glynnsim2_phi10 = PI * glynnsim2_phi1 / 180.0;
    glynnsim2_phi20 = PI * glynnsim2_phi2 / 180.0;
    glynnsim2_gamma = glynnsim2_thickness * (2.0 * glynnsim2_radius + glynnsim2_thickness) / (glynnsim2_radius + glynnsim2_thickness);
    glynnsim2_delta = glynnsim2_phi20 - glynnsim2_phi10;
    glynnsim2_abspow = abs(glynnsim2_pow);
    
    glynnsim3_radius1 = glynnsim3_radius + glynnsim3_thickness;
    glynnsim3_radius2 = sq(glynnsim3_radius) / glynnsim3_radius1;
    glynnsim3_gamma = glynnsim3_radius1 / (glynnsim3_radius1 + glynnsim3_radius2);
    glynnsim3_abspow = abs(glynnsim2_pow);
    
    hexes_obj = new Hexes(hexes_cellsize, hexes_power, hexes_rotate, hexes_scale);

    hypertile1_pa = TWO_PI / hypertile1_p;
    tmp = 1.0 - (cos(TWO_PI / hypertile1_p) - 1.0) / (cos(TWO_PI / hypertile1_p) + cos(TWO_PI / hypertile1_q));
    if(tmp>0) hypertile1_r = 1.0 / sqrt(tmp); else hypertile1_r=1.0;
    
    hypertile2_pa = TWO_PI / hypertile2_p;
    tmp = 1.0 - (cos(TWO_PI / hypertile2_p) - 1.0) / (cos(TWO_PI / hypertile2_p) + cos(TWO_PI / hypertile2_q));
    if(tmp>0) hypertile2_r = 1.0 / sqrt(tmp); else hypertile2_r=1.0;
    
    tmp = TWO_PI / hypertile_p;
    tmp2 = TWO_PI / hypertile_q;
    float tmp3 = (1.0 - cos(tmp)) / ((cos(tmp) + cos(tmp2)) + 1.0);
    if(tmp3 > 0) tmp3 = 1.0/sqrt(tmp3); else tmp3 = 1.0;
    tmp2 = hypertile_n * tmp;
    hypertile_re = tmp3 * cos(tmp2);
    hypertile_im = tmp3 * sin(tmp2);
    
    asteria_sina = sin(PI*asteria_alpha);
    asteria_cosa = cos(PI*asteria_alpha);
    
    tmp = 0.5 * ( bwrands_cellsize / (1.0 + sq(bwrands_space)));
    bwrands_g2 = sq(bwrands_gain) / tmp + 1.0e-6;
    tmp2 = bwrands_g2 * tmp;
    if(tmp2 > 2.0) tmp2 = 1.0;
    else tmp2 *= 1.0 / ( sq(tmp2)/4.0 + 1.0);
    bwrands_r2 = sq(tmp);
    bwrands_rfactor = tmp / tmp2;
    bwrands_petx = min(bwrands_minpetals,bwrands_maxpetals);
    bwrands_pety = abs(bwrands_maxpetals - bwrands_minpetals);

    juliaq_half_inv_power = 0.5 * juliaq_divisor / juliaq_power;
    juliaq_inv_power = juliaq_divisor / juliaq_power;
    juliaq_inv_power_2pi = TWO_PI / juliaq_power;
    
    if(lazyjess_n < 2) lazyjess_n = 2;
    lazyjess_vertex = PI * (lazyjess_n - 2) / (2 * lazyjess_n);
    lazyjess_sin_vertex = sin(lazyjess_vertex);
    lazyjess_pie_slice = TWO_PI/ lazyjess_n;
    lazyjess_half_slice = lazyjess_pie_slice / 2;
    lazyjess_corner_rotation = (lazyjess_corner - 1) * lazyjess_pie_slice;
    
    logapo_denom = 0.5 / log(logapo_base);
    
    logdb_denom = 0.5;
    if(logdb_base > 1.0e-10)
      logdb_denom = logdb_denom / log(2.71828182845905 * logdb_base);
    logdb_fixpe = PI;
    if(logdb_fix_period > 1.0e-10)
      logdb_fixpe *= logdb_fix_period;  
      
    loonie2_sqrvvar = sq(loonie2_weight);
    tmp = TWO_PI / loonie2_sides;
    loonie2_sina = sin(tmp);
    loonie2_cosa = cos(tmp);
    tmp = -TWO_PI / loonie2_star;
    loonie2_sins = sin(tmp);
    loonie2_coss = cos(tmp);
    tmp = TWO_PI / loonie2_circle;
    loonie2_sinc = sin(tmp);
    loonie2_cosc = cos(tmp);
    
    loonie3_sqrvvar = sq(loonie3_weight);
    
    if(nblur_numedges < 3) nblur_numedges = 3;
    if(nblur_numstripes != 0) {
      nblur_hasStripes = 1;
      if(nblur_numstripes < 0) {
        nblur_negStripes = 1;
        nblur_numstripes *= -1;
      } else nblur_negStripes = 0;
    } else {
      nblur_hasStripes = 0;
      nblur_negStripes = 0;
    }
    nblur_midAngle = TWO_PI / nblur_numedges;
    if(nblur_hasStripes == 1) {
      nblur_angStripes = nblur_midAngle / (2*nblur_numstripes);
      nblur_angStart = nblur_angStripes / 2.0;
      nblur_ratiocomplement = 2.0 - nblur_ratiostripes;
    }
    if(nblur_ratiohole>0.95 && nblur_exactcalc==1 && nblur_circumcircle==0)
      nblur_ratiohole = 0.95;
    nblur_tan90_m_2 = tan(HALF_PI + nblur_midAngle / 2.0);
    tmp = nblur_midAngle / 2.0;
    nblur_sina = sin(tmp);
    nblur_cosa = cos(tmp);
    if(nblur_highlightedges <= 0.1) nblur_highlightedges = 0.1;
    if(nblur_adjusttolinear == 1) {
      if(nblur_numedges%4==0)
        nblur_weight /= sqrt(2.0 - 2.0 * cos(nblur_midAngle * (nblur_numedges/2.0-1.0)))/2.0;
       else
        nblur_weight /= sqrt(2.0 - 2.0 * cos(nblur_midAngle * floor(nblur_numedges/2.0)))/2.0; 
    }
    if(nblur_circumcircle==1) {
      nblur_exactcalc = 0;
      nblur_highlightedges = 0.1;
    }
    nblur_speedCalc1 = nblur_ratiocomplement * nblur_angStart;
    nblur_speedCalc2 = nblur_ratiostripes * nblur_angStart;
    nblur_maxStripes = 2*nblur_numstripes;
    if(nblur_negStripes == 0) {
      nblur_arc_tan1 = (13.0/pow(nblur_numedges,1.3))*nblur_highlightedges;
      nblur_arc_tan2 = (2.0*atan(nblur_arc_tan1)/-2.0);
    } else {
      nblur_arc_tan1 = (7.5/pow(nblur_numedges,1.3))*nblur_highlightedges;
      nblur_arc_tan2 = (2.0*atan(nblur_arc_tan1)/-2.0);
    }

 }

PVector oscilloscope2(PVector p, float weight) {
  float t, pt = oscilloscope2_perturbation * sin(oscilloscope2_frequencyy * p.y);
  if(abs(oscilloscope2_damping)<1.0e-6) {
    t = oscilloscope2_amplitude * (cos(oscilloscope2_frequencyx * p.x + pt)) + oscilloscope2_separation;
  } else {
    t = oscilloscope2_amplitude * exp(-abs(p.x)*oscilloscope2_damping) * (cos(oscilloscope2_frequencyx * p.x + pt)) + oscilloscope2_separation;
  }
  
  if(abs(p.y)<=t) {
    return new PVector(weight * -p.x, weight * -p.y);
  } else {
    return new PVector(weight * p.x, weight * p.y);
  }
}

PVector devilwarp(PVector p, float weight) {
  float r2 = 1.0 / p.magSq();
  float r = pow(sq(p.x) + r2 * devilwarp_b * sq(p.y),devilwarp_warp) - pow(sq(p.y) + r2 * devilwarp_a * sq(p.x), devilwarp_warp);
  if(r>devilwarp_rmax) r = devilwarp_rmax;
  else if(r< devilwarp_rmin) r = devilwarp_rmin;
  r = devilwarp_effect * r;
  return new PVector(p.x * (1+r), p.y*(1+r));
}

 PVector bsplit(PVector p, float weight) {
   if(p.x+bsplit_shiftx == 0 || p.x + bsplit_shiftx == PI) {
     return new PVector(weight * p.x,weight * p.y);
   } else {
     float xx = weight / tan(p.x+bsplit_shiftx) * cos(p.y + bsplit_shifty);
     float yy = weight / sin(p.x+bsplit_shiftx) * (-1 * p.y + bsplit_shifty);
     return new PVector(xx,yy);
   }
 }

 class randXYData {
   float x,y;
   float lenXY, lenOuterEdges, lenInnerEdges;
 }

 void randXY(randXYData d) {
   float x, y;
   float xTmp, yTmp, lenOuterEdges = d.lenOuterEdges, lenInnerEdges=d.lenOuterEdges;
   float angXY, lenXY=d.lenXY;
   float ranTmp, angTmp, angMem;
   float ratioTmp, ratioTmpNum, ratioTmpDen;
   float speedCalcTmp;
   int count;
   
   if(nblur_exactcalc == 1)
     angXY = random(1)*TWO_PI;
    else
     angXY = (atan(nblur_arc_tan1*(random(1)-0.5))/(nblur_arc_tan2)+0.5 + ((int)random(32767))%((int)nblur_numedges)) * nblur_midAngle;
   x=sin(angXY);
   y=cos(angXY);
   angMem = angXY;
   while(angXY>nblur_midAngle)
     angXY -= nblur_midAngle;
   
   if(nblur_hasStripes == 1) {
     angTmp = nblur_angStart;
     count = 0;
     
     while(angXY > angTmp) {
       angTmp += nblur_angStripes;
       if(angTmp > nblur_midAngle) angTmp = nblur_midAngle;
       count++;
     }
     
     if(angTmp!=nblur_midAngle) angTmp -= nblur_angStart;
     
     if(nblur_negStripes == 0) {
       
       if(count%2==1) {
         if(angXY>angTmp) {
           angXY = angXY + nblur_angStart;
           angMem = angMem + nblur_angStart;
           x = sin(angMem);
           y = cos(angMem);
           angTmp += nblur_angStripes;
           count++;
         } else {
           angXY = angXY - nblur_angStart;
           angMem = angMem - nblur_angStart;
           x = sin(angMem);
           y = cos(angMem);
           angTmp -= nblur_angStripes;
           count--;
         }
       }  
         
         if(count%2==0 && nblur_ratiostripes >1.0) {
           if(angXY > angTmp && count!=nblur_maxStripes) {
             angMem = angMem - angXY + angTmp + (angXY-angTmp)/nblur_angStart * nblur_ratiostripes * nblur_angStart;
             angXY  = angTmp + (angXY-angTmp)/(nblur_angStart) * nblur_ratiostripes * nblur_angStart;
             x = sin(angMem);
             y = cos(angMem);
           } else {
             angMem = angMem - angXY + angTmp - (angTmp-angXY)/nblur_angStart * nblur_ratiostripes * nblur_angStart;
             angXY  = angTmp + (angXY-angTmp)/(nblur_angStart) * nblur_ratiostripes * nblur_angStart;
             x = sin(angMem);
             y = cos(angMem);
           }
         }
         
         if(count%2==0 && nblur_ratiostripes<1.0) {
             if(abs(angXY-angTmp) > nblur_speedCalc2 && count != nblur_maxStripes) {
               if((angXY-angTmp) > nblur_speedCalc2) {
                 ratioTmpNum = (angXY - (angTmp+nblur_speedCalc2))*nblur_speedCalc2;
                 ratioTmpDen = nblur_angStart - nblur_speedCalc2;
                 ratioTmp = ratioTmpNum/ratioTmpDen;
                 float t = angMem - angXY + angTmp + ratioTmp;
                 x = sin(t);
                 y = cos(t);
                 angXY = angTmp + ratioTmp;
               }
               if((angTmp-angXY) > nblur_speedCalc2) {
                 ratioTmpNum = (angTmp - nblur_speedCalc2-angXY)*nblur_speedCalc2;
                 ratioTmpDen = nblur_angStart - nblur_speedCalc2;
                 ratioTmp = ratioTmpNum/ratioTmpDen;
                 float t = angMem - angXY + angTmp - ratioTmp;
                 x = sin(t);
                 y = cos(t);
                 angXY = angTmp - ratioTmp;
               }
             }
             if(count==nblur_maxStripes) {
               if((angTmp-angXY)>nblur_speedCalc2) {
                 ratioTmpNum = (angTmp - nblur_speedCalc2-angXY)*nblur_speedCalc2;
                 ratioTmpDen = nblur_angStart - nblur_speedCalc2;
                 ratioTmp = ratioTmpNum/ratioTmpDen;
                 float t = angMem - angXY + angTmp - ratioTmp;
                 x = sin(t);
                 y = cos(t);
                 angXY = angTmp - ratioTmp;
               }
             }
           }  
 
     } else {
       ratioTmp = nblur_ratiostripes;
       nblur_ratiostripes = nblur_ratiocomplement;
       nblur_ratiocomplement = ratioTmp;
       speedCalcTmp = nblur_speedCalc1;
       nblur_speedCalc1 = nblur_speedCalc2;
       nblur_speedCalc2 = speedCalcTmp;
       
       if(count%2==0) {
         if(angXY>angTmp && count != nblur_maxStripes) {
           angXY = angXY + nblur_angStart;
           angMem = angMem + nblur_angStart;
           x = sin(angMem);
           y = cos(angMem);
           angTmp += nblur_angStripes;
           count++;
         } else {
           angXY = angXY - nblur_angStart;
           angMem = angMem - nblur_angStart;
           x = sin(angMem);
           y = cos(angMem);
           angTmp -= nblur_angStripes;
           count--;
         }
       }
       
       if(count%2==1 && nblur_ratiostripes >1.0) {
           if(angXY > angTmp && count!=nblur_maxStripes) {
             angMem = angMem - angXY + angTmp + (angXY-angTmp)/nblur_angStart * nblur_ratiostripes * nblur_angStart;
             angXY  = angTmp + (angXY-angTmp)/(nblur_angStart) * nblur_ratiostripes * nblur_angStart;
             x = sin(angMem);
             y = cos(angMem);
           } else {
             angMem = angMem - angXY + angTmp - (angTmp-angXY)/nblur_angStart * nblur_ratiostripes * nblur_angStart;
             angXY  = angTmp + (angXY-angTmp)/(nblur_angStart) * nblur_ratiostripes * nblur_angStart;
             x = sin(angMem);
             y = cos(angMem);
           }
         }
       
       if(count%2==1 && nblur_ratiostripes<1.0) {
             if(abs(angXY-angTmp) > nblur_speedCalc2 && count != nblur_maxStripes) {
               if((angXY-angTmp) > nblur_speedCalc2) {
                 ratioTmpNum = (angXY - (angTmp+nblur_speedCalc2))*nblur_speedCalc2;
                 ratioTmpDen = nblur_angStart - nblur_speedCalc2;
                 ratioTmp = ratioTmpNum/ratioTmpDen;
                 float t = angMem - angXY + angTmp + ratioTmp;
                 x = sin(t);
                 y = cos(t);
                 angXY = angTmp + ratioTmp;
               }
               if((angTmp-angXY) > nblur_speedCalc2) {
                 ratioTmpNum = (angTmp - nblur_speedCalc2-angXY)*nblur_speedCalc2;
                 ratioTmpDen = nblur_angStart - nblur_speedCalc2;
                 ratioTmp = ratioTmpNum/ratioTmpDen;
                 float t = angMem - angXY + angTmp - ratioTmp;
                 x = sin(t);
                 y = cos(t);
                 angXY = angTmp - ratioTmp;
               }
             }
             if(count==nblur_maxStripes) {
               angTmp = nblur_midAngle;
               if((angTmp-angXY)>nblur_speedCalc2) {
                 ratioTmpNum = (angTmp - nblur_speedCalc2-angXY)*nblur_speedCalc2;
                 ratioTmpDen = nblur_angStart - nblur_speedCalc2;
                 ratioTmp = ratioTmpNum/ratioTmpDen;
                 float t = angMem - angXY + angTmp - ratioTmp;
                 x = sin(t);
                 y = cos(t);
                 angXY = angTmp - ratioTmp;
               }
             }
           }
       
         ratioTmp = nblur_ratiostripes;
       nblur_ratiostripes = nblur_ratiocomplement;
       nblur_ratiocomplement = ratioTmp;
       speedCalcTmp = nblur_speedCalc1;
       nblur_speedCalc1 = nblur_speedCalc2;
       nblur_speedCalc2 = speedCalcTmp;
       
     }
   } 
   
   xTmp = nblur_tan90_m_2 /(nblur_tan90_m_2 - tan(angXY));
   yTmp = xTmp * tan(angXY);
   lenOuterEdges = sqrt(sq(xTmp)+sq(yTmp));
   
   if(nblur_exactcalc == 1) {
     if(nblur_equalblur == 1) ranTmp = sqrt(random(1));
     else ranTmp = random(1);
   } else {
     if(nblur_circumcircle == 1) {
       if(nblur_equalblur == 1) ranTmp = sqrt(random(1));
       else ranTmp = random(1);
     } else {
       if(nblur_equalblur == 1) ranTmp = sqrt(random(1)) * lenOuterEdges;
       else ranTmp = random(1) * lenOuterEdges;
     }
   }
   
   lenInnerEdges = nblur_ratiohole * lenOuterEdges;
   
   if(nblur_exactcalc == 0) {
     if(ranTmp<lenInnerEdges) {
       if(nblur_circumcircle == 1) {
         if(nblur_equalblur == 1) ranTmp = lenInnerEdges + sqrt(random(1)) * (1.0 - lenInnerEdges + 1.0e-6);
         else ranTmp = lenInnerEdges + random(1) * (1.0 - lenInnerEdges + 1.0e-6);
       } else {
         if(nblur_equalblur == 1) ranTmp = lenInnerEdges + sqrt(random(1)) * (lenOuterEdges - lenInnerEdges);
         else ranTmp = lenInnerEdges + random(1) * (lenOuterEdges - lenInnerEdges);
       }
     }
   }
   
   x*=ranTmp;
   y*=ranTmp;
   lenXY = sqrt(sq(x)+sq(y));
   
   d.x = x;
   d.y = y;
   d.lenXY = lenXY;
   d.lenInnerEdges = lenInnerEdges;
   d.lenOuterEdges = lenOuterEdges;
 }

 PVector nblur(PVector p, float weight) {
   randXYData data = new randXYData();
   randXY(data);
   
   if(nblur_exactcalc == 1 && nblur_circumcircle == 0)
     while( (data.lenXY < data.lenInnerEdges) || (data.lenXY > data.lenOuterEdges)) randXY(data);
   
   if(nblur_exactcalc == 1 && nblur_circumcircle == 1)
     while( (data.lenXY < data.lenInnerEdges)) randXY(data);
   
   float x = nblur_weight * weight * (nblur_cosa * data.x - nblur_sina * data.y);
   float y = nblur_weight * weight * (nblur_sina * data.x + nblur_cosa * data.y);
   
   return new PVector(3*x,3*y);
   
 }

 PVector murl(PVector p, float weight) {
   float c = murl_c;
   if( murl_power-1 > 1e-6) {
     c/=murl_power = 1.0;
   }
   float p2 = murl_power / 2.0;
   float vp = weight * (c+1);
   float a = atan2(p.y,p.x) * murl_power;
   float sina = sin(a);
   float cosa = cos(a);
   
   float r = c * pow(p.magSq(),p2);
   float re = r * cosa + 1.0;
   float im = r * sina;
   float r1 = vp / (sq(re) + sq(im));
   
   float x = r1 * (p.x * re + p.y * im);
   float y = r1 * (p.y * re - p.x * im);
   
   return new PVector(x,y);
 }

 PVector murl2(PVector p, float weight) {
   float p2 = murl2_power / 2.0;
   float invp,vp;
   if(abs(murl2_power)>1.0e-6) {
     invp = 1.0 / murl2_power;
     if(murl2_c == -1.0) vp =0.0;
     else vp = weight * pow(murl2_c + 1.0, 2.0 / murl2_power); 
   } else {
     invp = 1.0e10;
     vp = weight * pow(murl2_c + 1.0, 4);
   }
   float a = atan2(p.y,p.x) * murl2_power;
   float sina = sin(a);
   float cosa = cos(a);
   
   float r = murl2_c * pow(p.magSq(),p2);
   float re = r * cosa + 1.0;
   float im = r * sina;
   
   r = pow(sq(re) + sq(im), invp);
   a = atan2(im,re) * 2.0 * invp;
   re = r*cos(a);
   im = r*sin(a);
   float r1 = vp / sq(r);
   
   float x = r1 * (p.x * re + p.y * im);
   float y = r1 * (p.y * re - p.x * im);
   
   return new PVector(x,y);
   
 }

 PVector mcarpet(PVector p, float weight) {
   float t = p.magSq() / 4.0 + 1.0;
   float r = 1.0/t;
   float x = p.x * r * mcarpet_x;
   float y = p.y * r * mcarpet_y;
   x += (1.0 - (mcarpet_twist * sq(p.x)) + p.y);
   y += mcarpet_tilt * p.x;
   return new PVector(weight * x, weight * y);
 }
   
 PVector loonie3(PVector p, float weight) {
   float r2 = 2 * loonie3_sqrvvar;
   if(p.x>1.0e-10) {
     r2 = sq(p.magSq() / p.x);
   }
   
   float r = weight;
   if(r2 < loonie3_sqrvvar) {
     r *= sqrt(loonie3_sqrvvar / r2 -1.0);
   }
   return new PVector(r*p.x,r*p.y);
 }

 PVector loonie2(PVector p, float weight) {
   float xrt = p.x;
   float yrt = p.y;
   float swp;
   float r2 = xrt * loonie2_coss + abs(yrt) * loonie2_sins;
   float circle = p.mag();
   int i;
   for(i =0;i<loonie2_sides-1;i++) {
     swp = xrt * loonie2_cosa - yrt * loonie2_sina;
     yrt = xrt * loonie2_sina + yrt * loonie2_cosa;
     xrt = swp;
     
     r2 = max(r2, xrt * loonie2_coss + abs(yrt) * loonie2_sins);
   }
   
   r2 = r2 * loonie2_cosc + circle * loonie2_sinc;
   if(i>1)
     r2 = sq(r2);
    else
     r2 = abs(r2)*r2;
     
   float x,y;  
   if(r2>0 && (r2<loonie2_sqrvvar)) {
     float r = weight * sqrt(abs(loonie2_sqrvvar / r2 - 1.0));
     x = r*p.x;
     y = r*p.y;
   } else {
     if(r2<0) {
       float r = weight / sqrt(abs(loonie2_sqrvvar / r2) - 1.0);
       x = r * p.x;
       y = r * p.y;
     } else {
       x = weight * p.x;
       y = weight * p.y;
     }
   }
   
   return new PVector(x,y); 
 }

 PVector logdb(PVector p, float weight) {
   float fap = 0.0;
   int adp;
   for(int i=0;i<7;i++) {
     adp = (int)random(-5,5);
     if(abs(adp)>=3) adp = 0;
     fap += adp;
   }
   fap *= logdb_fixpe;
   float x = weight * logdb_denom * log(p.magSq());
   float y = weight * (atan2(p.y,p.x) + fap);
   return new PVector(x,y);
 }

 PVector logapo(PVector p, float weight) {
   float x = weight * log(p.magSq()) * logapo_denom;
   float y = weight * atan2(p.y,p.x);
   return new PVector(x,y);
 }
 
 PVector lissajous(PVector p, float weight) {
   float t = (lissajous_tmax-lissajous_tmin) * random(1) + lissajous_tmin;
   float y = random(-0.5,0.5);
   float x1 = sin(lissajous_a * t + lissajous_d);
   float y1 = sin(lissajous_b * t);
   
   return new PVector(weight * (x1 + lissajous_c * t + lissajous_e * y), weight * (y1 + lissajous_c * t + lissajous_e * y) );
 }

 PVector lineart(PVector p, float weight) {
   float xx = sgn(p.x) * pow(abs(p.x),lineart_powx) * weight;
   float yy = sgn(p.y) * pow(abs(p.y),lineart_powy) * weight;
   return new PVector(xx,yy);
 }
   
 PVector lazyjess(PVector p, float weight) {
   float theta, sina, cosa;
   float x = p.x;
   float y = p.y;
   float modulus = p.mag();
   
   if(lazyjess_n==2) {
    
     if(abs(x) < lazyjess_weight) {
       theta = atan2(y,x) + lazyjess_spin;
       sina = sin(theta);
       cosa = cos(theta);
       x = lazyjess_weight * modulus * cosa;
       y = lazyjess_weight * modulus * sina;
       
       if(abs(x) >= lazyjess_weight) {
         theta = atan2(y,x) - lazyjess_spin + lazyjess_corner_rotation;
         sina = sin(theta);
         cosa = cos(theta);
         x = lazyjess_weight * modulus * cosa;
         y = -lazyjess_weight * modulus * sina;         
       }
     } else {
       modulus = 1.0 + lazyjess_space / modulus;
       x = lazyjess_weight * modulus * x;
       y = lazyjess_weight * modulus * y;
     }
     
   } else {
     
     theta = atan2(y,x) + TWO_PI;
     float theta_diff = (theta+lazyjess_half_slice) % lazyjess_pie_slice;
     float r = lazyjess_weight * M_SQRT2 * lazyjess_sin_vertex / sin(PI - theta_diff - lazyjess_vertex);
     
     if(modulus < r) {
       theta = atan2(y,x) + lazyjess_spin + TWO_PI;
       sina = sin(theta);
       cosa = cos(theta);
       x = lazyjess_weight * modulus * cosa;
       y = lazyjess_weight * modulus * sina;
       
       theta_diff = (theta + lazyjess_half_slice) % lazyjess_pie_slice;
       r = lazyjess_weight * M_SQRT2 * lazyjess_sin_vertex / sin(PI - theta_diff - lazyjess_vertex);
       modulus = sqrt(sq(x)+sq(y));
       
       if(modulus >= r) {
         theta = atan2(y,x) - lazyjess_spin + lazyjess_corner_rotation + TWO_PI;
         sina = sin(theta);
         cosa = cos(theta);
         x = lazyjess_weight * modulus * cosa;
         y = lazyjess_weight * modulus * sina;
       }
       
     } else {
       modulus = 1.0 + lazyjess_space / modulus;
       x = lazyjess_weight * modulus * x;
       y = lazyjess_weight * modulus * y;
     }
     
   }
   
   return new PVector(weight * x, weight * y);
 }

 PVector vibration2(PVector p, float weight) {
   float d_along_dir = p.x * cos(vibration2_dir) + p.y * sin(vibration2_dir);
   float dirL = vibration2_dir + modulate(vibration2_dm, vibration2_dmfreq, d_along_dir);
   float angleL = vibration2_angle + modulate(vibration2_tm, vibration2_tmfreq, d_along_dir);
   float freqL = modulate(vibration2_fm, vibration2_fmfreq, d_along_dir) / (vibration2_freq+1.0e-10);
   float ampL = vibration2_amp + vibration2_amp * modulate(vibration2_am, vibration2_amfreq, d_along_dir);

   float total_angle = angleL + dirL;
   float cos_dir = cos(dirL);
   float sin_dir = sin(dirL);
   float cos_tot = cos(total_angle);
   float sin_tot = sin(total_angle);
   float scaled_freq = vibration2_freq * TWO_PI;
   float phase_shift = TWO_PI * vibration2_phase / (vibration2_freq + 1.0e-10);
   d_along_dir = p.x * cos_dir + p.y * sin_dir;
   float local_amp = ampL * sin((d_along_dir * scaled_freq) + freqL + phase_shift);
   
   float x = p.x + local_amp * cos_tot;
   float y = p.y + local_amp * sin_tot;
   
   d_along_dir = p.x * cos(vibration2_dir2) + p.y * sin(vibration2_dir2);
   dirL = vibration2_dir2 + modulate(vibration2_d2m, vibration2_d2mfreq, d_along_dir);
   angleL = vibration2_angle2 + modulate(vibration2_t2m, vibration2_t2mfreq, d_along_dir);
   freqL = modulate(vibration2_f2m, vibration2_f2mfreq, d_along_dir) / (vibration2_freq2 + 1.0e-10);
   ampL = vibration2_amp2 + vibration2_amp2 * modulate(vibration2_a2m, vibration2_a2mfreq, d_along_dir);

   total_angle = angleL + dirL;
   cos_dir = cos(dirL);
   sin_dir = sin(dirL);
   cos_tot = cos(total_angle);
   sin_tot = sin(total_angle);
   scaled_freq = vibration2_freq2 * TWO_PI;
   phase_shift = TWO_PI* vibration2_phase2 / (vibration2_freq2 + 1.0e-10);
   d_along_dir = p.x * cos_dir + p.y * sin_dir;
   local_amp = ampL * sin((d_along_dir * scaled_freq) + freqL + phase_shift);

   x += local_amp * cos_tot;
   y += local_amp * sin_tot;

   return new PVector(weight * x, weight * y);
 }

 PVector layeredspiral(PVector p, float weight) {
   float r = p.x * layeredspiral_radius;
   float t = p.magSq();
   return new PVector(weight * r * cos(t), weight * r * sin(t));
 }

 final float c45 = cos(45.0);
 final float s45 = sin(45.0);
 
 PVector kaleidoscope(PVector p, float weight) {
   float xx = ((kaleidoscope_rotate * p.x) * c45 - p.y * s45 + kaleidoscope_lineup ) + kaleidoscope_x;
   float yy;
   if(p.y > 0.0)
     yy = (( kaleidoscope_rotate * p.y) * c45 + p.x * s45 + kaleidoscope_pull + kaleidoscope_lineup ) + kaleidoscope_y;
    else 
     yy = (( kaleidoscope_rotate * p.y) * c45 + p.x * s45 - kaleidoscope_pull - kaleidoscope_lineup ) ;
     
   return new PVector(weight * xx, weight * yy);  
 }

 PVector juliaq(PVector p, float weight) {
   float a = atan2(p.y,p.x) * juliaq_inv_power + random(1) * juliaq_inv_power_2pi;
   float sina = sin(a);
   float cosa = cos(a);
   float r = weight * pow(p.magSq(),juliaq_half_inv_power);
   return new PVector(r*cosa, r*sina);
 }

 PVector funnel2(PVector p, float weight) {
    float xx = tanh(p.x) * (1.0 / cos(p.x) + funnel2_effect * PI);
    float yy = tanh(p.y) * (1.0 / cos(p.y) + funnel2_effect * PI);
    
    return new PVector(weight * xx, weight * yy);
  }

  PVector funnel(PVector p, float weight) {
    float xx = tanh(p.x) * (1.0 / cos(p.y) + funnel_effect * PI);
    float yy = tanh(p.y) * (1.0 / cos(p.y) + funnel_effect * PI);
    
    return new PVector(weight * xx, weight * yy);
  }

  PVector ennepers(PVector p, float weight) {
    float xx = (p.x - ((sq(p.x) * p.x) / 3.0)) + p.x * sq(p.y);
    float yy = (p.y - ((sq(p.y) * p.y) / 3.0)) + p.y * sq(p.x);
    
    return new PVector(weight * xx, weight * yy);
  }

  PVector circlize2(PVector p, float weight) {
    float absx = abs(p.x);
    float absy = abs(p.y);
    float side, perimeter, r, sina, cosa;
    
    if(absx >= absy) {
       if(p.x >= absy) perimeter = absx+p.y;
       else perimeter = 5.0 * absx - p.y;
       side = absx;
    } else {
      if(p.y >= absx) perimeter = 3.0 * absy - p.x;
      else perimeter = 7.0 * absy + p.x;
      side = absy;
    }
    
    r = weight * (side + circlize2_hole);
    float a = QUARTER_PI * perimeter / side - QUARTER_PI;
    sina = sin(a);
    cosa = cos(a);
    
    return new PVector(r * sina, r * cosa);
  } 

  PVector bwrands(PVector p, float weight) {
    float vx = p.x;
    float vy = p.y;
    
    if(bwrands_cellsize == 0.0) return new PVector(weight * p.x,weight * p.y);
    
    int ix = floor( vx / bwrands_cellsize );
    int iy = floor( vy / bwrands_cellsize );
    float cx = (ix+0.5) * bwrands_cellsize;
    float cy = (iy+0.5) * bwrands_cellsize;
    
    int xx = ix ^ 0xb641;
    int yy = iy ^ 0x9d81;
    int xy = xx*yy + (int)bwrands_seed;
    xx &= 0xffff;
    yy &= 0xffff;
    xy &= 0xffff;

    int tt = bytemix(xx,yy);
    yy = bytemix(yy,xx);
    xx = tt;
    tt = byteshf(xx,yy);
    yy = byteshf(xy,yy);
    xx = tt;
    tt = bytexim(xx,yy);
    yy = bytexim(yy,xx);
    xx = tt;
    
    float ssz = (float)xx / 65535.0;
    ssz = bwrands_rmin + ssz * (1.0 - bwrands_rmin);
    float aan = bwrands_rrot * TWO_PI * (float)yy / 65536.0;

    tt = byteprimes(xx,yy);
    yy = byteprimes(yy,xx);
    xx = tt;

    float looniechance = - (float)xx/65536.0 + bwrands_loonie_chance;
    float petalschance = -1.0;
    if(looniechance < 0.0)  petalschance = looniechance + bwrands_petals_chance;
  
    float npetals = 1.0/3.0;
    if(bwrands_pety == 0) npetals = bwrands_petx;
    else npetals = bwrands_petx + (yy >> 3) % (1.0+bwrands_pety);

    if(looniechance <= petalschance) looniechance = -1.0;

    float lx = vx - cx;
    float ly = vy - cy;

    float vv2 = ssz * bwrands_r2;
    float l2 = sq(lx) + sq(ly);
    if( l2 > vv2) {
      return new PVector(weight * vx, weight * vy);
    }
    
    if(looniechance >0.0) {
      float r = vv2 / (l2+1.0e-10) - 1.0;
      r = sqrt(r);
      lx *= r;
      ly *= r;
      vv2 = 1.0; 
    } else if( petalschance > 0.0) {
      float flwr = npetals / TWO_PI * (PI + atan2(ly,lx));
      flwr = flwr - (int)flwr;
      flwr = abs(flwr - 0.5) * 2.0;
      float r = sqrt(l2);
      petalschance = random(1);
      if(petalschance < 0.5 * (flwr+0.5)) {
        lx *= (1.0-r) * (flwr*1.1);
        ly *= (1.0-r) * (flwr*1.1);
      } else {
        vv2 = sqrt(vv2);
        lx *= (vv2 - r * (1.0-flwr))/(r+1.0e-10);
        ly *= (vv2 - r * (1.0-flwr))/(r+1.0e-10);
      }
      vv2 = 1.0;
    } else {
      lx *= bwrands_g2 ;
      ly *= bwrands_g2 ;
      float r = bwrands_rfactor / ( (sq(lx)+sq(ly))/(4.0*ssz) + 1.0);
      lx *= r;
      ly *= r;
      vv2 = sqrt(ssz);
    }
    
    float r = vv2 * (sq(lx)+sq(ly)) / bwrands_r2;
    float theta = bwrands_inner_twist * (1.0-r) + bwrands_outer_twist * r;
    float s = sin(theta+aan);
    float c = cos(theta+aan);
    
    vx = cx + c * lx + s * ly;
    vy = cy - s * lx + c * ly;
    
    return new PVector(weight * vx, weight * vy);
  }

  PVector asteria(PVector p, float weight) {
    float x0 = weight * p.x;
    float y0 = weight * p.y;
    float xx = x0;
    float yy = y0;
    float r = sq(xx) + sq(yy);
    xx = sq(abs(xx)-1.0);
    yy = sq(abs(yy)-1.0);
    float r2 = sqrt(xx+yy);
    boolean in1 = r < 1.0;
    boolean out2 = r2 < 1.0;
    if(in1 && out2)
      in1 = (random(1)>0.35);
    else
      in1 = !in1;
    if(in1) {
      return new PVector(x0,y0);
    } else {
      xx = x0 * asteria_cosa - y0 * asteria_sina;
      yy = x0 * asteria_sina + y0 * asteria_cosa;
      float nx = xx / sqrt(1.0 - yy * yy) * (1.0 - sqrt(1.0 - sq(-abs(yy) + 1.0)));
      xx = nx * asteria_cosa + yy * asteria_sina;
      yy = -nx * asteria_sina + yy * asteria_cosa;
      return new PVector(xx,yy);
    }
  }

  PVector juliac(PVector p, float weight) {
    float re = 1.0 /(juliac_re + 1.0e-10);
    float im = juliac_im / 100.0;
    float arg = atan2(p.y,p.x) + (random(MAX_INT) % juliac_re) * TWO_PI;
    float lnmod = juliac_dist * 0.5 * log(p.magSq());
    float a = arg * re + lnmod * im;
    float mod2 = weight * exp(lnmod * re - arg * im);
    
    return new PVector(mod2 * cos(a), mod2 * sin(a));
  }

  PVector jacsn(PVector p, float weight) {
    Jacobi_elliptic_result jac_x = new Jacobi_elliptic_result();
    Jacobi_elliptic(p.x,jacsn_k,jac_x);
    Jacobi_elliptic_result jac_y = new Jacobi_elliptic_result();
    Jacobi_elliptic(p.y,1.0-jacsn_k,jac_y);
    
    float numx = jac_x.sn * jac_y.dn;
    float numy = jac_x.cn * jac_x.dn * jac_y.cn * jac_y.sn;
    float denom = sq(jac_x.sn) * sq(jac_y.sn) * jacsn_k + sq(jac_y.cn);
    denom = weight / (1.0e-10+denom);
    
    return new PVector(denom * numx, denom * numy);
  }

  PVector jacdn(PVector p, float weight) {
    Jacobi_elliptic_result jac_x = new Jacobi_elliptic_result();
    Jacobi_elliptic(p.x,jacdn_k,jac_x);
    Jacobi_elliptic_result jac_y = new Jacobi_elliptic_result();
    Jacobi_elliptic(p.y,1.0-jacdn_k,jac_y);
    
    float numx = jac_x.dn * jac_y.cn * jac_y.dn;
    float numy = -jac_x.cn * jac_x.sn * jac_y.sn * jacdn_k;
    float denom = sq(jac_x.sn) * sq(jac_y.sn) * jacdn_k + sq(jac_y.cn);
    denom = weight / (1.0e-10+denom);
    
    return new PVector(denom * numx, denom * numy);
  }

  PVector jaccn(PVector p, float weight) {
    Jacobi_elliptic_result jac_x = new Jacobi_elliptic_result();
    Jacobi_elliptic(p.x,jaccn_k,jac_x);
    Jacobi_elliptic_result jac_y = new Jacobi_elliptic_result();
    Jacobi_elliptic(p.y,1.0-jaccn_k,jac_y);
    
    float numx = jac_x.cn * jac_y.cn;
    float numy = -jac_x.dn * jac_x.sn * jac_y.dn * jac_y.sn;
    float denom = sq(jac_x.sn) * sq(jac_y.sn) * jaccn_k + sq(jac_y.cn);
    denom = weight / (1.0e-10+denom);
    
    return new PVector(denom * numx, denom * numy);
  }

  PVector hypertile(PVector p, float weight) {
    float a = p.x + hypertile_re;
    float b = p.y + hypertile_im;
    
    float c = hypertile_re * p.x - hypertile_im * p.y + 1.0;
    float d = hypertile_re * p.y + hypertile_im * p.x;
    
    float vr = weight / (sq(c) + sq(d));
    
    return new PVector(vr * (a*c+b*d), vr * (b*c-a*d));
  }

  PVector hypertile2(PVector p, float weight) {
    float a = p.x + hypertile2_r;
    float b = p.y;
    
    float c = hypertile2_r * p.x + 1.0;
    float d = hypertile2_r * p.y;
    
    float x = (a*c + b*d);
    float y = (b*c - a*d);
    
    float vr = weight / (sq(c) + sq(d));
    float rpa = hypertile2_pa * random(0,MAX_INT);
    float sina = sin(rpa);
    float cosa = cos(rpa);
    
    float xx = vr * (x * cosa + y * sina);
    float yy = vr * (y * cosa - x * sina);
    
    return new PVector(xx,yy);
  }

  PVector hypertile1(PVector p, float weight) {
    float rpa = random(0,MAX_INT) * hypertile1_pa;
    float sina = sin(rpa);
    float cosa = cos(rpa);
    float re = hypertile1_r * cosa;
    float im = hypertile1_r * sina;
    float a = p.x + re;
    float b = p.y - im;
    
    float c = re * p.x - im * p.y + 1;
    float d = re * p.y + im * p.x;
    
    float vr = weight / (sq(c) + sq(d));
    
    float x = vr * (a * c + b * d);
    float y = vr * (b * c - a * d);
    
    return new PVector(x,y);
  }

  PVector hexes(PVector p, float weight) {
    return hexes_obj.transform(p,weight);
  }

  PVector heartwf(PVector p, float weight) {
    float a = atan2(p.x,p.y);
    float r = p.mag();
    float nx,t;
    if(a < 0.0) {
      t = -a / PI * 60.0 * heartwf_scale_t_left - heartwf_shift_t;
      if(t>60.0) t=60.0;
      nx = -0.001 * (-t*t + 40.0 * t + 1200.0) * sin(PI * t/180.0) * r;
    } else {
      t = a / PI * 60.0 * heartwf_scale_t_right - heartwf_shift_t;
      if(t>60.0) t=60.0;
      nx = 0.001 * (-t*t + 40.0 * t + 1200.0) * sin(PI * t/180.0) * r;
    }
    float ny = -0.001 * (-t*t+40.0*t+400) * cos(PI * t/180.0) * r;
    nx *= heartwf_scale_x;
    return new PVector(weight * nx, weight * ny);
  }
  
  PVector glynnia(PVector p, float weight) {
    float r = p.mag();
    float d;
    if(r>1.0) {
      if(random(1)>0.5) {
        d = 1.0e-10 + sqrt(r + p.x);
        return new PVector(weight * HSQRT2 * d, -weight * HSQRT2 / d * p.y);
      } else {
        d = r + p.x;
        float dx = sqrt(r * (sq(p.y) + sq(d))) + 1.0e-10;
        r = weight / dx;
        return new PVector(r*d, r*p.y);
      }
    } else {
      if(random(1)>0.5) {
        d = 1.0e-10 + sqrt(r + p.x);
        return new PVector(-weight * HSQRT2 * d, -weight * HSQRT2 / d * p.y);
      } else {
        d = r + p.x;
        float dx = sqrt(r * (sq(p.y) + sq(d))) + 1.0e-10;
        r = weight / dx;
        return new PVector(-r*d, r*p.y);
      }
    }
  }

  final PVector glynnsim3_circle() {
    float phi = TWO_PI * random(1);
    float r;
    if(random(1) < glynnsim3_gamma)
      r = glynnsim3_radius1;
     else
      r = glynnsim3_radius2;
     return new PVector(r * cos(phi), r * sin(phi));
  }

  PVector glynnsim3(PVector p, float weight) {
    float r = p.mag();
    if(r < glynnsim3_radius1) {
      PVector toolpoint = glynnsim3_circle();
      toolpoint.mult(weight);
      return toolpoint;
    } else {
      float alpha = glynnsim3_radius / r;
      float x = p.x;
      float y = p.y;
      if(random(1) <= glynnsim2_contrast * pow(alpha, glynnsim3_abspow)) {
        float tmp = sq(alpha);
        x = tmp * p.x;
        y = tmp * p.y;
      }
      return new PVector(weight * x, weight * y);
    }
  }
 

  final PVector glynnsim2_circle() {
    float r = glynnsim2_radius + glynnsim2_thickness - glynnsim2_gamma * random(1);
    float phi = glynnsim2_phi10 + glynnsim2_delta * random(1);
    return new PVector(r * cos(phi), r * sin(phi));
  }

  PVector glynnsim2(PVector p, float weight) {
    float r = p.mag();
    if(r < glynnsim2_radius) {
      PVector toolpoint = glynnsim2_circle();
      toolpoint.mult(weight);
      return toolpoint;
    } else {
      float alpha = glynnsim2_radius / r;
      float x = p.x;
      float y = p.y;
      if(random(1) <= glynnsim2_contrast * pow(alpha, glynnsim2_abspow)) {
        float tmp = sq(alpha);
        x = tmp * p.x;
        y = tmp * p.y;
      }
      return new PVector(weight * x, weight * y);
    }
  }


  final PVector glynnsim1_circle() {
    float r = glynnsim1_radius1 * (glynnsim1_thickness + (1.0 - glynnsim1_thickness) * random(1));
    float phi = TWO_PI * random(1);
    return new PVector(r * cos(phi) + glynnsim1_x1, r * sin(phi) + glynnsim1_y1);
  }

  PVector glynnsim1(PVector p, float weight) {
    float r = p.mag();
    if(r < glynnsim1_radius) {
      PVector toolpoint = glynnsim1_circle();
      toolpoint.mult(weight);
      return toolpoint;
    } else {
      float alpha = glynnsim1_radius / r;
      float x = p.x;
      float y = p.y;
      if(random(1) <= glynnsim1_contrast * pow(alpha, glynnsim1_abspow)) {
        float tmp = sq(alpha);
        x = tmp * p.x;
        y = tmp * p.y;
      }
      float z = sq(x - glynnsim1_x1) + sq(y - glynnsim1_y1);
      if(z < sq(glynnsim1_radius1)) {
        PVector toolpoint = glynnsim1_circle();
        toolpoint.mult(weight);
        return toolpoint;
      } else {
        return new PVector(weight * x, weight * y);
      }
    }
  }

final float gdoffs_agdod = 0.1;
final float gdoffs_agdoa = 2.0;
final float gdoffs_agdoc = 1.0;

final float gdoffs_fclp(float a) {return ((a<0)?-(abs(a)%1.0):abs(a)%1.0);}
final float gdoffs_fscl(float a) {return gdoffs_fclp((a+1.0)/2.0);}
final float gdoffs_fosc(float p, float a) {return gdoffs_fscl(-cos(p*a*TWO_PI));}
final float gdoffs_flip(float a, float b, float c) {return (c*(b-a)+a);}

  PVector gdoffs(PVector p, float weight) {
    float osc_x = gdoffs_fosc(gdoffs_gdodx,1.0);
    float osc_y = gdoffs_fosc(gdoffs_gdody,1.0);
    float in_x = p.x + gdoffs_gdocx;
    float in_y = p.y + gdoffs_gdocy;
    float out_x, out_y;
    if(gdoffs_square != 0.0) {
      out_x = gdoffs_flip(gdoffs_flip(in_x,gdoffs_fosc(in_x,4),osc_x),gdoffs_fosc(gdoffs_fclp(gdoffs_gdob*in_x),4),osc_x);
      out_y = gdoffs_flip(gdoffs_flip(in_y,gdoffs_fosc(in_y,4),osc_x),gdoffs_fosc(gdoffs_fclp(gdoffs_gdob*in_y),4),osc_x);
    } else {
      out_x = gdoffs_flip(gdoffs_flip(in_x,gdoffs_fosc(in_x,4),osc_x),gdoffs_fosc(gdoffs_fclp(gdoffs_gdob*in_x),4),osc_x);
      out_y = gdoffs_flip(gdoffs_flip(in_y,gdoffs_fosc(in_y,4),osc_y),gdoffs_fosc(gdoffs_fclp(gdoffs_gdob*in_y),4),osc_y);
    }
    return new PVector(weight * out_x, weight * out_y);
  }

  PVector fourth(PVector p, float weight) {
    if(p.x >0.0 && p.y >0.0) {
      float a = atan2(p.y,p.x);
      float r = 1.0 / p.mag();
      return new PVector(weight * r * cos(a), weight * r * sin(a));
    } else if(p.x > 0.0 && p.y < 0.0) {
      float r2 = p.magSq();
      float r = weight;
      if(r2 < fourth_sqrvvar)
        r *= sqrt(fourth_sqrvvar / r2 - 1.0);
      return new PVector(r * p.x, r * p.y);
    } else if(p.x <0.0 && p.y > 0.0) {
      float x = p.x-fourth_x;
      float y = p.y-fourth_y;
      float r = sqrt(x*x+y*y);
      if(r< fourth_weight) {
        float a = atan2(y,x) + fourth_spin + fourth_twist * (fourth_weight - r);
        r *= weight;
        return new PVector(r * cos(a) + fourth_x, r * sin(a) - fourth_y);
      } else {
        r = weight * (1.0 + fourth_space / r);
        return new PVector( r * x + fourth_x, r * y - fourth_y);
      }
    } else {
      return new PVector(weight * p.x, weight * p.y);
    }
  }

  PVector flipy(PVector p, float weight) {
    float y = p.y;
    if(p.x>0.0) y=-y;
    return new PVector(weight * p.x, weight * y); 
  }

  PVector flipcircle(PVector p, float weight) {
    float y = p.y;
    if(p.magSq() <= sq(flipcircle_weight)) y=-y;
    return new PVector(weight * p.x, weight * y); 
  }

  PVector fibonacci2(PVector p, float weight) {
    float a = p.y * FNATLOG;
    float snum1 = sin(a);
    float cnum1 = cos(a);
    float b = -(p.x * PI + a);
    float snum2 = sin(b);
    float cnum2 = cos(b);
    float eradius1 = fibonacci2_sc * exp(fibonacci2_sc2 * (p.x * FNATLOG));
    float eradius2 = fibonacci2_sc * exp(fibonacci2_sc2 * ((p.x * FNATLOG - p.y * PI) * -1.0));
    float x = weight * (eradius1 * cnum1 - eradius2 * cnum2) * FFIVE;
    float y = weight * (eradius1 * snum1 - eradius2 * snum2) * FFIVE;
    return new PVector(x,y);
  }

  PVector epispiral(PVector p, float weight) {
    float theta = atan2(p.y,p.x);
    float t = epispiral_holes;
    float d = cos(epispiral_n * theta);
    if(d == 0) d = 1.0e-10;
    if(abs(epispiral_thickness) > 1.0e-10) {
      t+= (random(1) * epispiral_thickness) * (1.0/d);
    } else {
      t+= 1.0/d;
    }
    return new PVector(weight * t * cos(theta),weight * t * sin(theta));
  }

  PVector epispiralwf(PVector p, float weight) {
    float a = atan2(p.x,p.y);
    float d = cos(epispiralwf_waves * a);
    if(d == 0.0) d = 1.0e-10;
    float r = 0.5 / d;
    return new PVector(weight * r * sin(a),weight * r * cos(a));
  }

  PVector eclipse(PVector p, float weight) {
    float xx=p.x;
    float yy=p.y;
    if (abs(p.y) <= eclipse_weight) {
      float c_2 = sqrt(sq(eclipse_weight) - sq(p.y));

      if (abs(p.x) <= c_2) {
        float x = p.x + eclipse_shift * eclipse_weight;
        if (abs(x) >= c_2)
          xx = -eclipse_weight * p.x;
        else
          xx = eclipse_weight * x;
      } 
    } 
    
    return new PVector(weight * xx,weight * yy);
  }

  PVector eswirl(PVector p, float weight) {
    float tmp = p.magSq() + 1.0;
    float tmp2 = 2.0 * p.x;
    float xmax = (safesqrt(tmp+tmp2) + safesqrt(tmp-tmp2))*0.5;
    if(xmax<1.0) xmax = 1.0;
    float mu = acosh(xmax);
    float t = p.x / xmax;
    if(t>1.0) t = 1.0;
     else if(t<-1.0) t = -1.0;
    float nu = acos(t);
    if(p.y<0.0) nu *= -1.0;
    nu = nu + mu * eswirl_out + eswirl_in / mu;
    return new PVector(weight * cosh(mu) * cos(nu), weight * sinh(mu) * sin(nu));
  }
  
  PVector escale(PVector p, float weight) {
    float tmp = p.magSq() + 1.0;
    float tmp2 = 2.0 * p.x;
    float xmax = (safesqrt(tmp+tmp2) + safesqrt(tmp-tmp2))*0.5;
    if(xmax<1.0) xmax = 1.0;
    float mu = acosh(xmax);
    float t = p.x / xmax;
    if(t>1.0) t = 1.0;
     else if(t<-1.0) t = -1.0;
    float nu = acos(t);
    if(p.y<0.0) nu *= -1.0;
    mu *= escale_scale;
    nu = ((escale_scale * (nu + PI + escale_angle)) % (TWO_PI * escale_scale) - escale_angle - escale_scale * PI) % TWO_PI;
    if(nu > PI) nu -= TWO_PI;
    if(nu < -PI) nu += TWO_PI;
    return new PVector(weight * cosh(mu) * cos(nu), weight * sinh(mu) * sin(nu));
  }
  
  PVector erotate(PVector p, float weight) {
    float tmp = p.magSq()+1.0;
    float tmp2 = 2.0 * p.x;
    float xmax = (safesqrt(tmp + tmp2) + safesqrt(tmp-tmp2))*0.5;
    if(xmax < 1.0) xmax = 1.0;
    float t = p.x/xmax;
    if(t>1.0) t = 1.0;
     else if(t<-1.0) t = -1.0;
    float nu = acos(t);
    if(p.y<0.0) nu *= -1.0;
    nu = (nu + erotate_rotate + PI) % TWO_PI - PI;
    float x = weight * xmax * cos(nu);
    float y = sqrt(xmax - 1.0) * sqrt(xmax + 1.0) * sin(nu);
    return new PVector(x,y);
  }
  
  PVector epush(PVector p, float weight) {
    float tmp = p.magSq() + 1.0;
    float tmp2 = 2.0 * p.x;
    float xmax = (safesqrt(tmp+tmp2) + safesqrt(tmp-tmp2))*0.5;
    if(xmax<1.0) xmax = 1.0;
    float mu = acosh(xmax);
    float t = p.x / xmax;
    if(t>1.0) t = 1.0;
     else if(t<-1.0) t = -1.0;
    float nu = acos(t);
    if(p.y<0.0) nu *= -1.0;
    nu += epush_rotate;
    mu *= epush_dist;
    mu += epush_push;
    return new PVector(weight * cosh(mu) * cos(nu), weight * sinh(mu) * sin(nu));
  }
  
  PVector emotion(PVector p, float weight) {
    float tmp = p.magSq() + 1.0;
    float tmp2 = 2.0 * p.x;
    float xmax = (safesqrt(tmp+tmp2) + safesqrt(tmp-tmp2))*0.5;
    if(xmax<1.0) xmax = 1.0;
    float mu = acosh(xmax);
    float t = p.x / xmax;
    if(t>1.0) t = 1.0;
     else if(t<-1.0) t = -1.0;
    float nu = acos(t);
    if(p.y<0.0) nu *= -1.0;
    if(nu < 0.0) mu += emotion_move;
    else mu -= emotion_move;
    if(mu <= 0.0) {
      mu *= -1.0;
      nu *= -1.0;
    }
    nu += emotion_rotate;
    return new PVector(weight * cosh(mu) * cos(nu), weight * sinh(mu) * sin(nu));
  }
  
  PVector emod(PVector p, float weight) {
    float tmp = p.magSq() + 1.0;
    float tmp2 = 2.0 * p.x;
    float xmax = (safesqrt(tmp+tmp2) + safesqrt(tmp-tmp2))*0.5;
    if(xmax<1.0) xmax = 1.0;
    float mu = acosh(xmax);
    float t = p.x / xmax;
    if(t>1.0) t = 1.0;
     else if(t<-1.0) t = -1.0;
    float nu = acos(t);
    if(p.y<0.0) nu *= -1.0;
    if( (mu < emod_radius) && (-mu < emod_radius)) {
      if(nu > 0.0)
        mu = (mu+emod_radius+emod_distance*emod_radius) % (2.0 * emod_radius) - emod_radius;
       else
        mu = (mu-emod_radius-emod_distance*emod_radius) % (2.0 * emod_radius) + emod_radius;
    }
    return new PVector(weight * cosh(mu) * cos(nu), weight * sinh(mu) * sin(nu));
  }
  
  PVector ejulia(PVector p, float weight) {
    float r2 = p.magSq();
    float x;
    if(ejulia_power >= 0) x = p.x;
    else {
      r2 = 1.0/r2;
      x = p.x * r2;
    }
    float tmp = r2 + 1.0;
    float tmp2 = 2.0 * x;
    float xmax = 0.5 * (safesqrt(tmp+tmp2) + safesqrt(tmp-tmp2));
    if(xmax<1.0) xmax = 1.0;
    float mu = acosh(xmax);
    float t = x / xmax;
    if(t>1.0) t = 1.0;
     else if(t<-1.0) t = -1.0;
    float nu = acos(t);
    if(p.y<0.0) nu *= -1.0;
    nu = nu / ejulia_power + TWO_PI / ejulia_power * floor(random(1) * ejulia_power);
    mu /= ejulia_power;
    return new PVector(weight * 2.0 * cosh(mu) * cos(nu), weight * 2.0 * sinh(mu) * sin(nu));
  }

  PVector ecollide(PVector p, float weight) {
    float tmp = p.magSq()+1.0;
    float tmp2 = 2.0 * p.x;
    float xmax = (safesqrt(tmp + tmp2) + safesqrt(tmp-tmp2))*0.5;
    if(xmax < 1.0) xmax = 1.0;
    float t = p.x/xmax;
    if(t>1.0) t = 1.0;
     else if(t<-1.0) t = -1.0;
    float nu = acos(t);
    int alt = (int)(nu * ecollide_ecn_pi);
    if(alt%2 ==0)
        nu = alt * ecollide_pi_ecn + (nu + ecollide_eca_ecn) % ecollide_pi_ecn;
      else
        nu = alt * ecollide_pi_ecn + (nu - ecollide_eca_ecn) % ecollide_pi_ecn;
    if(p.y<0.0) nu *= -1.0;
    float x = weight * xmax * cos(nu);
    float y = sqrt(xmax - 1.0) * sqrt(xmax + 1.0) * sin(nu);
    return new PVector(x,y);
  }

  PVector dlawf(PVector p, float weight) {
    return dlawf_obj.transform(p,weight);
  }

  PVector dcperlin(PVector p, float weight) {
    int t=0;
    float Vx = p.x;
    float Vy = p.y;
    PVector V = new PVector(p.x,p.y);
    float r, theta, s,c,pn,e;
    
    noiseDetail((int)dcperlin_octaves,dcperlin_freqs);
    do {
      e = 0.0;
      switch((int)dcperlin_shape) {
        case 0: 
         // Vx = (1.0 + dcperlin_edge) * (random(0,1) - 0.5);
         // Vy = (1.0 + dcperlin_edge) * (random(0,1) - 0.5);
          r = sq(Vx) > sq(Vy) ? abs(Vx) : abs(Vy);
          if (r > (1.0 - dcperlin_edge)) {
            e = 0.5 * (r - 1.0 + dcperlin_edge) / dcperlin_edge;
          }
          break;
        case 1:
          r = random(0,1) + random(0,1);
          r = (r > 1.0) ? 2.0 - r : r;
          r *= (1.0 + dcperlin_edge);
          if (r > 1.0 - dcperlin_edge) {
            e = 0.5 * (r - 1.0 + dcperlin_edge) / dcperlin_edge;
          }
          //theta = random(0,TWO_PI);
          theta = atan2(p.x,p.y);
          s = sin(theta);
          c = cos(theta);
          Vx = 0.5 * r * s;
          Vy = 0.5 * r * c;
          break;
        case 2:
          r = (1.0 + dcperlin_edge) * random(0,1);
          if (r > 1.0 - dcperlin_edge) {
            e = 0.5 * (r - 1.0 + dcperlin_edge) / dcperlin_edge;
          }
          //theta = random(0,TWO_PI);
          theta = atan2(p.x,p.y);
          s = sin(theta);
          c = cos(theta);
          Vx = 0.5 * r * s;
          Vy = 0.5 * r * c;
          break;  
      }
      
      switch((int)dcperlin_map) {
        case 0:
          V = new PVector(dcperlin_scale * Vx, dcperlin_scale * Vy, dcperlin_scale * dcperlin_z);
          break;

        case 1:
          r = 1.0 / (sq(Vx) + sq(Vy) + 1.0e-10);
          V = new PVector(dcperlin_scale * Vx * r, dcperlin_scale * Vy * r, dcperlin_scale * dcperlin_z);
          break;

        case 2:
          r = 1.0 / (sq(Vx) + sq(Vy) + 0.5);
          V = new PVector(dcperlin_scale * Vx * r, dcperlin_scale * Vy * r, dcperlin_scale * dcperlin_z);
          break;

        case 3:
          r = 1.0 / (sq(Vx) + sq(Vy) + 0.25);
          V = new PVector(dcperlin_scale * Vx * r, dcperlin_scale * Vy * r, dcperlin_scale * dcperlin_z);
          break;

        case 4:
          r = 0.25 - (Vx * Vx + Vy * Vy);
          if (r < 0.0) {
            r = sqrt(-r);
          }
          else {
            r = sqrt(r);
          }
          V = new PVector(dcperlin_scale * Vx, dcperlin_scale * Vy, dcperlin_scale * (r+dcperlin_z));
          break;

        case 5:
          r = 0.25 - (Vx * Vx + Vy * Vy);
          if (r < 0.0) {
            r = sqrt(-r);
          }
          else {
            r = sqrt(r);
          }
          V = new PVector(dcperlin_scale * Vx, dcperlin_scale * Vy, dcperlin_scale * (2*r+dcperlin_z));
          break;
      }
      
      pn = noise(V.x, V.y, V.z)*2.0-1.0;
      
      if (pn > 0.0) {
        e = pn * (1.0 + e * e * 20.0) + 2.0 * e;
      }
      else {
        e = pn * (1.0 + e * e * 20.0) - 2.0 * e;
      }
      
    } while( (e<dcperlin_notch_bottom || e > dcperlin_notch_top) && t++ < dcperlin_select_bailout);
    
    if( abs(pn+dcperlin_centre) < dcperlin_range)    
      return new PVector(weight * 3.0 * Vx, weight * 3.0 * Vy);
     else
      return new PVector(p.x,p.y);
  }

  PVector crop(PVector p, float weight) {
    if((p.x < crop_left || p.x > crop_right || p.y < crop_top || p.y > crop_bottom) && (crop_zero == 1.0)) {
      return new PVector(0,0);
    } else {
      float x=p.x,y=p.y;
      if(p.x<crop_left) x = crop_left + random(0,1) * crop_w;
      else if(p.x>crop_right) x = crop_right - random(0,1) * crop_w;
      if(p.y<crop_top) y = crop_top + random(0,1) * crop_h;
      else if(p.y>crop_bottom) y = crop_bottom - random(0,1) * crop_h;
      
      return new PVector(weight * x, weight * y);
    }
  }

  PVector crackle(PVector p, float weight) {
     return crackle_obj.transform(p,weight);
  }

  PVector collideoscope(PVector p, float weight) {
    float a = atan2(p.y,p.x);
    float r = p.mag();
    int alt;
    if(a >= 0.0) {
      alt = (int)(a * collideoscope_kn_pi);
      if(alt % 2 == 0)
        a = alt * collideoscope_pi_kn + (collideoscope_ka_kn + a) % collideoscope_pi_kn;
       else
        a = alt * collideoscope_pi_kn + (-collideoscope_ka_kn + a) % collideoscope_pi_kn;
    } else {
      alt = (int)(-a * collideoscope_kn_pi);
      if(alt % 2 == 1)
        a = -(alt * collideoscope_pi_kn + (-collideoscope_ka_kn - a) % collideoscope_pi_kn);
       else
        a = -(alt * collideoscope_pi_kn + (collideoscope_ka_kn - a) % collideoscope_pi_kn);
    }
    
    return new PVector(weight * r * cos(a), weight * r * sin(a));
  }
    
  PVector cloverleaf(PVector p, float weight) {
    float a = atan2(p.x,p.y);
    float r = 3.0 * (sin(2*a) + 0.25 * sin(6*a));
    if(cloverleaf_filled == 1.0) r *= random(0,1);
    return new PVector(weight * r * sin(a), weight * r * cos(a));
  }

  PVector circlize(PVector p, float weight) {
    float absx = abs(p.x);
    float absy = abs(p.y);
    float perimeter, side;
    if(absx >= absy) {
     if(p.x >= absy)
      perimeter = absx + p.y; 
     else
      perimeter = 5.0 * absx - p.y;
     side = absx; 
    } else {
      if(p.y >= absx)
       perimeter = 3.0 * absy - p.x;
      else
       perimeter = 7.0 * absy + p.x;
      side = absy;
    }
    
    float r = side / QUARTER_PI + circlize_hole;
    float a = QUARTER_PI * perimeter / side - QUARTER_PI;
    return new PVector(weight * r * cos(a), weight * r * sin(a));
  }

  PVector circlecrop(PVector p, float weight) {
    float x = p.x - circlecrop_x;
    float y = p.y - circlecrop_y;
    float ang = atan2(y,x);
    float rad = sqrt(sq(x)+sq(y));
    float rdc = circlecrop_radius + (random(0,1) * 0.5 * circlecrop_scatterarea);
    boolean esc = rad > circlecrop_radius;
    boolean cr0 = circlecrop_zero == 1.0;
    
    if (cr0 && esc) {
      return new PVector(weight*x,weight*y);
    }
    else if (cr0 && !esc) {
      return new PVector(weight * p.x, weight * p.y);
    }
    else if (!cr0 && esc) {
      return new PVector(weight * rdc * cos(ang) + circlecrop_x,
                 weight * rdc * sin(ang) + circlecrop_y);
    }
    else if (!cr0 && !esc) {
      return new PVector(weight * p.x, weight * p.y);
    }
    return new PVector(weight * p.x, weight * p.y);
  }

  PVector circleblur(PVector p, float weight) {
    float rad = sqrt(random(0,2));
    float a = random(0,1) * TWO_PI;
    return new PVector(weight * cos(a) * rad, weight * sin(a) * rad);
  }

  PVector checks(PVector p, float weight) {
    int isxy = (int)round(p.x * checks_cs) + (int)round(p.y * checks_cs);
    float rnx = checks_rnd * random(0,1);
    float rny = checks_rnd * random(0,1);
    float dx, dy;
    if(isxy % 2 == 0) {
      dx = -checks_x + rnx;
      dy = -checks_y;
    } else {
      dx = checks_x;
      dy = checks_y + rny;
    }
    return new PVector(weight * (p.x + dx), weight * (p.y + dy));
  }

  PVector cannabiscurvewf(PVector p, float weight) {
    float a = atan2(p.x, p.y);
    float r = (1.0 + 9.0 / 10.0 * cos(8.0 * a)) * (1.0 + 1.0 / 10.0 * cos(24.0 * a)) * (9.0 / 10.0 + 1.0 / 10.0 * cos(200.0 * a)) * (1.0 + sin(a));    
    
    if(cannabiscurvewf_filled == 1.0) r *= random(0,1);
    return new PVector(weight * cos(a) * r, -weight * sin(a) * r+2.0);
  }

  PVector boarders2(PVector p, float weight) {
    float roundx = round(p.x);
    float roundy = round(p.y);
    float offsetx = p.x - roundx;
    float offsety = p.y - roundy;
    float x,y;
    if(random(0,1) >= boarders2_cr) {
      x = offsetx * boarders2_c + roundx;
      y = offsety * boarders2_c + roundy;
    } else {
      if(abs(offsetx) >= abs(offsety)) {
        if(offsetx >= 0.0) {
          x = offsetx * boarders2_c + roundx + boarders2_cl;
          y = offsety * boarders2_c + roundy + boarders2_cl * offsety/offsetx;
        } else {
          x = offsetx * boarders2_c + roundx - boarders2_cl;
          y = offsety * boarders2_c + roundy - boarders2_cl * offsety/offsetx;
        }
      } else {
        if(offsety >= 0.0) {
          y = offsety * boarders2_c + roundy + boarders2_cl;
          x = offsetx * boarders2_c + roundx + offsetx/offsety * boarders2_cl;
        } else {
          y = offsety * boarders2_c + roundy - boarders2_cl;
          x = offsetx * boarders2_c + roundx - offsetx/offsety * boarders2_cl;
        }
      }
    }
    
    return new PVector(weight * x, weight * y);
   }

  PVector blurzoom(PVector p, float weight) {
    float z = 1.0 + blurzoom_length * random(0,1);
    float x = weight * ((p.x - blurzoom_x) * z + blurzoom_x);   
    float y = weight * ((p.y - blurzoom_y) * z + blurzoom_y);
    return new PVector(x,y);
  }

  PVector blocky(PVector p, float weight) {
    float r = weight / ((cos(p.x) + cos(p.y)) / blocky_mp + 1.0);
    float tmp = sq(p.y) + sq(p.x) + 1.0;
    float x2 = 2.0 * p.x;
    float y2 = 2.0 * p.y;
    float xmax = 0.5 * (sqrt(tmp + x2) + sqrt(tmp - x2));
    float ymax = 0.5 * (sqrt(tmp + y2) + sqrt(tmp - y2));
    float a = p.x / xmax;
    float b = safesqrt(1.0 - sq(a));
    float x = blocky_weight * r*atan2(a,b)*blocky_x / HALF_PI;
    a = p.y / ymax;
    b = safesqrt(1.0 - sq(a));
    float y = blocky_weight * r * atan2(a,b)*blocky_y / HALF_PI;
    
    return new PVector(3.0*x,3.0*y);
  }

  PVector bilinear(PVector p, float weight) {
    return new PVector(weight * p.y, weight * p.x);
  }

  PVector barycentroid(PVector p, float weight) {
    float barycentroid_dot02 = barycentroid_a * p.x + barycentroid_b * p.y;
    float barycentroid_dot12 = barycentroid_c * p.x + barycentroid_d * p.y;
    
    float u = (barycentroid_dot11 * barycentroid_dot02 - barycentroid_dot01 * barycentroid_dot12) * barycentroid_invdenom;
    float v = (barycentroid_dot00 * barycentroid_dot12 - barycentroid_dot01 * barycentroid_dot02) * barycentroid_invdenom;
    
    float um = sqrt(sq(u) + sq(p.x)) * sgn(u);
    float vm = sqrt(sq(v) + sq(p.y)) * sgn(v);
    
    return new PVector(weight * um, weight * vm);
  }

  PVector bwraps7(PVector p, float weight) {
    if(abs(bwraps7_cellsize) < 1e-10) 
      return new PVector(weight * p.x, weight * p.y);
     
    float cx = (floor(p.x / bwraps7_cellsize) + 0.5) * bwraps7_cellsize;
    float cy = (floor(p.y / bwraps7_cellsize) + 0.5) * bwraps7_cellsize;
    float lx = p.x - cx;
    float ly = p.y - cy;
    if( (sq(lx) + sq(ly)) > bwraps7_r2)
        return new PVector(weight * p.x, weight * p.y);
    
    lx *= bwraps7_g2;
    ly *= bwraps7_g2;
    float r = bwraps7_rfactor / ((sq(lx) + sq(ly))/ 4.0 + 1.0);
    lx *= r;
    ly *= r;
    
    r = (sq(lx) + sq(ly)) / bwraps7_r2;
    float theta = bwraps7_inner_twist * (1.0 - r) + bwraps7_outer_twist * r;
    float s = sin(theta);
    float c = cos(theta);
    
    float x = cx + c * lx + s * ly;
    float y = cy - s * lx + c * ly;
    
    return new PVector(weight * x, weight * y);
  }

  PVector btransform(PVector p, float weight) {
    float tau = 0.5 * (log(sq(p.x+1.0) + sq(p.y)) - log(sq(p.x - 1.0) + sq(p.y))) / btransform_power + btransform_move;
    float sigma = PI - atan2(p.y, p.x+1.0) - atan2(p.y, 1.0 - p.x) + btransform_rotate;
    sigma = sigma / btransform_power + TWO_PI / btransform_power * floor(random(0,1) * btransform_power);
    if(p.x >= 0.0)
      tau += btransform_split;
     else
      tau -= btransform_split;
    float temp = cosh(tau) - cos(sigma);  
    return new PVector(weight * sinh(tau) / temp, weight * sin(sigma) / temp);
  }

  PVector bswirl(PVector p, float weight) {
    float tau = 0.5 * (log(sq(p.x+1.0) + sq(p.y)) - log(sq(p.x - 1.0) + sq(p.y)));
    float sigma = PI - atan2(p.y, p.x+1.0) - atan2(p.y, 1.0 - p.x);
    sigma = sigma + tau * bswirl_out + bswirl_in / tau;
    float temp = cosh(tau) - cos(sigma);  
    return new PVector(weight * sinh(tau) / temp, weight * sin(sigma) / temp);
  }

  PVector bmod(PVector p, float weight) {
    float tau = 0.5 * (log(sq(p.x+1.0) + sq(p.y)) - log(sq(p.x - 1.0) + sq(p.y)));
    float sigma = PI - atan2(p.y, p.x+1.0) - atan2(p.y, 1.0 - p.x);
    if(tau < bmod_radius && -tau < bmod_radius)
      tau = (tau + bmod_radius + bmod_distance * bmod_radius) % (2.0 * bmod_radius) - bmod_radius;
    float temp = cosh(tau) - cos(sigma);  
    return new PVector(weight * sinh(tau) / temp, weight * sin(sigma) / temp);
  }

  PVector bcollide(PVector p, float weight) {
    float tau = 0.5 * (log(sq(p.x+1.0) + sq(p.y)) - log(sq(p.x - 1.0) + sq(p.y)));
    float sigma = PI - atan2(p.y, p.x+1.0) - atan2(p.y, 1.0 - p.x);
    int alt = (int)(sigma * bcollide_bcn_pi);
    if(alt % 2 == 0)
      sigma = alt * bcollide_pi_bcn + (sigma + bcollide_bca_bcn) % bcollide_pi_bcn;
     else
      sigma = alt * bcollide_pi_bcn + (sigma - bcollide_bca_bcn) % bcollide_pi_bcn;
    float temp = cosh(tau) - cos(sigma);  
    return new PVector(weight * sinh(tau) / temp, weight * sin(sigma) / temp);
  }


  PVector vlog(PVector p, float weight) {
    return new PVector(weight * 0.5 * log(sq(p.x)+sq(p.y)), weight * atan2(p.y,p.x));
  }

  PVector vsin(PVector p, float weight) {
    return new PVector(weight * sin(p.x) * cosh(p.y), weight * cos(p.x) * sinh(p.y));
  }
  
  PVector vcos(PVector p, float weight) {
    return new PVector(weight * cos(p.x) * cosh(p.y), -weight * sin(p.x) * sinh(p.y));
  } 

  PVector vtan(PVector p, float weight) {
    float d = weight / (1.0e-10 + cos(2.0*p.x) + cosh(2.0*p.y));
    return new PVector(d * sin(2.0 * p.x), d * sinh(2.0 * p.y));
  }
 
  PVector sec(PVector p, float weight) {
    float d = weight * 2.0 / (1.0e-10 + cos(2.0*p.x) + cosh(2.0*p.y));
    return new PVector(d * cos(p.x) * cosh(p.y), d * sin(p.x) * sinh(p.y));
  }

  PVector csc(PVector p, float weight) {
    float d = weight * 2.0 / (1.0e-10 + cosh(2.0*p.y) - cos(2.0*p.x));
    return new PVector(d * sin(p.x) * cosh(p.y), -d * cos(p.x) * sinh(p.y));
  }

   PVector cot(PVector p, float weight) {
    float d = weight / (1.0e-10 + cosh(2.0*p.y) - cos(2.0 * p.x));
    return new PVector(d * sin(2.0 * p.x), -d * sinh(2.0 * p.y));
  }  
  
  PVector vsinh(PVector p, float weight) {
    return new PVector(weight * sinh(p.x) * cos(p.y), weight * cosh(p.x) * sin(p.y));
  }
  
  PVector vcosh(PVector p, float weight) {
    return new PVector(weight * cosh(p.x) * cos(p.y), weight * sinh(p.x) * sin(p.y));
  } 

  PVector vtanh(PVector p, float weight) {
    float d = weight / (1.0e-10 + cos(2.0*p.y) + cosh(2.0*p.x));
    return new PVector(d * sinh(2.0 * p.x), d * sin(2.0 * p.y));
  }
  
  PVector sech(PVector p, float weight) {
    float d = weight * 2.0 / (1.0e-10 + cos(2.0*p.y) + cosh(2.0*p.x));
    return new PVector(d * cos(p.y) * cosh(p.x), -d * sin(p.y) * sinh(p.x));
  }

  PVector csch(PVector p, float weight) {
    float d = weight * 2.0 / (1.0e-10 + cosh(2.0*p.x) - cos(2.0*p.y));
    return new PVector(d * sinh(p.x) * cos(p.y), -d * cosh(p.x) * sin(p.y));
  }

   PVector coth(PVector p, float weight) {
    float d = weight / (1.0e-10 + cosh(2.0*p.x) - cos(2.0 * p.y));
    return new PVector(d * sinh(2.0 * p.x), d * sin(2.0 * p.y));
  } 

  PVector waves2(PVector p, float weight) {
    float x = weight * (p.x + waves2_scalex * sin(p.y * waves2_freqx));
    float y = weight * (p.y + waves2_scaley * sin(p.x * waves2_freqy));
    return new PVector(x,y);
  }
  
  PVector auger(PVector p, float weight) {
    float s = sin(auger_freq * p.x);
    float t = sin(auger_freq * p.y);
    float dy = p.y + auger_weight * (auger_scale * s * 0.5 + abs(p.y) * s);
    float dx = p.x + auger_weight * (auger_scale * t * 0.5 + abs(p.x) * t);
    float x = weight * (p.x + auger_sym * (dx - p.x));
    return new PVector(x,weight * dy);
  }

  PVector flux(PVector p, float weight) {
    float xpw = p.x + flux_weight;
    float xmw = p.x - flux_weight;
    float avgr = weight * (2+flux_spread) * sqrt(sqrt(sq(p.y) + sq(xpw)) / (1.0e-10+sqrt(sq(p.y) + sq(xmw))));
    float avga = (atan2(p.y,xmw) - atan2(p.y,xpw))*0.5;
    
    return new PVector(avgr * cos(avga)-(2+flux_spread), avgr * sin(avga));
  }

  PVector mobius(PVector p, float weight) {
    float re_u = mobius_re_a * p.x - mobius_im_a * p.y + mobius_re_b;
    float im_u = mobius_re_a * p.y + mobius_im_a * p.x + mobius_re_b;
    float re_v = mobius_re_c * p.x - mobius_im_c * p.y + mobius_re_d;
    float im_v = mobius_re_c * p.y + mobius_im_c * p.x + mobius_re_d;
    
    float d = (sq(re_v) + sq(im_v)) + 1.0e-10;
    float rad_v = weight / d;
    float x = rad_v * (re_u * re_v + im_u * im_v);
    float y = rad_v * (im_u * re_v - re_u * im_v);
    return new PVector(x,y);
  }

  PVector whorl(PVector p, float weight) {
    float r = p.mag();
    float a;
    if(r<whorl_weight)
      a = atan2(p.y,p.x) + whorl_inside / (whorl_weight - r);
     else
      a = atan2(p.y,p.x) + whorl_outside / (whorl_weight - r);
    return new PVector(weight * r * cos(a), weight * r * sin(a));  
  }

  PVector wedge(PVector p, float weight) {
    float r = p.mag();
    float a = atan2(p.y,p.x)+wedge_swirl * r;
    float c = floor((wedge_count * a + PI) / PI * 0.5);
    float comp_fac = 1.0 - wedge_angle * wedge_count / PI * 0.5;
    a = a * comp_fac + c * wedge_angle;
    r = weight * (r+wedge_hole);
    return new PVector(r * cos(a), r * sin(a));
  }

  PVector wedgesph(PVector p, float weight) {
    float r = 1.0 / (p.mag()+1.0e-10);
    float a = atan2(p.y,p.x)+wedgesph_swirl * r;
    float c = floor((wedge_count * a + PI) /PI * 0.5);
    float comp_fac = 1.0 - wedge_angle * wedge_count / PI * 0.5;
    a = a * comp_fac + c * wedge_angle;
    r = weight * (r+wedge_hole);
    return new PVector(r * cos(a), r * sin(a));
  }
  
  PVector stripes(PVector p, float weight) {
    float roundx = floor(p.x+0.5);
    float offsetx = p.x-roundx;
    float x = weight * (offsetx * (1.0-stripes_space) + roundx);
    float y = weight * (p.y + sq(offsetx) * stripes_warp);
    return new PVector(x,y); 
  }
  
  PVector split(PVector p, float weight) {
    float x,y;
    if(cos(p.x*split_xsize * PI) >= 0)
      y = weight * p.y;
     else
      y = -weight * p.y;
    if(cos(p.y*split_ysize * PI) >= 0)
      x = weight * p.x;
     else
      x = -weight * p.x;
    return new PVector(x,y);  
  }  

  PVector splits(PVector p, float weight) {
    float x,y;
    if(p.x>= 0)
      x = weight * (p.x + splits_x);
     else
      x = weight * (p.x - splits_x);
    if(p.y>= 0)
      y = weight * (p.y + splits_y);
     else
      y = weight * (p.y - splits_y);
    return new PVector(x,y);  
  }
  
  PVector separation(PVector p, float weight) {
    float x,y;
    if(p.x>0)
      x = weight * (sqrt(sq(p.x)+separation_x2) - p.x*separation_xinside);
     else
      x = -weight * (sqrt(sq(p.x)+separation_x2) + p.x*separation_xinside);
    if(p.y>0)
      y = weight * (sqrt(sq(p.y)+separation_y2) - p.y*separation_yinside);
     else
      y = -weight * (sqrt(sq(p.y)+separation_y2) + p.y*separation_yinside);  
     return new PVector(x,y); 
  }
  
  PVector popcorn2(PVector p, float weight) {
    float x = weight * (p.x + popcorn2_x * sin(tan(p.y * popcorn2_c)));
    float y = weight * (p.y + popcorn2_y * sin(tan(p.x * popcorn2_c)));
    return new PVector(x,y);
  }
  
  PVector oscilloscope(PVector p, float weight) {
    float t;
    if(oscilloscope_damping < 0.1)
      t = oscilloscope_amplitude * cos(oscilloscope_frequency * p.x) + oscilloscope_separation;
     else
      t = oscilloscope_amplitude * exp(-abs(p.x) * oscilloscope_damping) * cos(oscilloscope_frequency * p.x) + oscilloscope_separation;
     
     if(abs(p.y) <= t)
       return new PVector(weight*p.x, weight*-p.y);
     else
       return new PVector(weight*p.x, weight*p.y); 
  }
  
  PVector modulus(PVector p, float weight) {
    float x,y;
    if(p.x > modulus_x) {
      x = weight * (-modulus_x + (p.x+modulus_x) % (2 * modulus_x));
    } else if (p.x < -modulus_x) {
      x = weight * (modulus_x - (modulus_x - p.x) % (2 * modulus_x));
    } else x = weight * p.x;
    
    if(p.y > modulus_y) {
      y = weight * (-modulus_y + (p.y+modulus_y) % (2 * modulus_y));
    } else if (p.y < -modulus_y) {
      y = weight * (modulus_y - (modulus_y - p.y) % (2 * modulus_y));
    } else y = weight * p.y;
    
    return new PVector(x,y);
  }
  
  PVector lazysuzan(PVector p, float weight) {
    float xx = p.x - lazysuzan_x;
    float yy = p.y - lazysuzan_y;
    float rr = sqrt(sq(xx)+sq(yy));
    
    if(rr < lazysuzan_weight) {
      float a = atan2(yy,xx) + lazysuzan_spin + lazysuzan_twist * (lazysuzan_weight - rr);
      rr = weight * rr;
      return new PVector(rr * cos(a) + lazysuzan_x, rr * sin(a) - lazysuzan_y);
    } else {
      rr = weight * (1.0 + lazysuzan_space / rr);
      return new PVector(rr * xx + lazysuzan_x, rr * yy - lazysuzan_y);
    }
  }
  
  PVector escher(PVector p, float weight) {
    float a = atan2(p.y, p.x);
    float lnr = 0.5 * log(p.magSq());
    float m = weight * exp(escher_vc * lnr - escher_vd * a);
    float n = escher_vc * a + escher_vd * lnr;
    return new PVector(m * cos(n), m * sin(n));
  }
  
  PVector edisc(PVector p, float weight) {
    float tmp = sq(p.x)+sq(p.y)+1.0;
    float tmp2 = p.x + p.x;
    float xmax = (sqrt(tmp + tmp2) + sqrt(tmp - tmp2)) * 0.5;
    float a1 = log(xmax + sqrt(xmax -1.0));
    float a2 = -acos(p.x / xmax);
    float w = weight / 4;
    float snv = p.y > 0.0 ? sin(a1) : -sin(a1);
    return new PVector( w * cosh(a2) * cos(a1), w * sinh(a2) * snv);
  }
  
  PVector elliptic(PVector p, float weight) {
    float tmp = sq(p.x)+sq(p.y)+1.0;
    float tmp2 = p.x + p.x;
    float xmax = (sqrt(tmp + tmp2) + sqrt(tmp - tmp2)) * 0.5;
    float a = p.x / xmax;
    float b = safesqrt(1.0 - sq(a));
    float x = weight * elliptic_v * atan2(a,b);
    float y = weight * elliptic_v * (random(0,1)<0.5?-1:1) * log(xmax + safesqrt(xmax-1.0));
    return new PVector(x,y);
  }
  
  PVector curve(PVector p, float weight) {
    float x = weight * (p.x + curve_xamp * exp(-p.y*p.y / curve_xlength2));
    float y = weight * (p.y + curve_yamp * exp(-p.x*p.x / curve_ylength2));
    return new PVector(x,y);
  }
  
  PVector lines(PVector p, float weight) {
    float r;
    if(lines_squared==1) r=0.5*sq(randomGaussian());
      else r=0.25*randomGaussian();
    float y = lines_scale * (floor(p.y/lines_scale) - 0.5 + r);
    return new PVector(weight * p.x, weight * y);      
  }

  PVector flower(PVector p, float weight) {
    float d = p.mag() + 1.0e-10;
    float r = weight * xmax * (random(0,1) - flower_holes) * cos(flower_petals * atan2(p.y,p.x)) / d;
    return new PVector(r * p.x, r * p.y);      
  }
  
  PVector spherical(PVector p, float weight) {
    float r = weight / (sq(p.x)+sq(p.y) + 1.0e-10);
    return new PVector(r * p.x, r * p.y);      
  }
  
  PVector horseshoe(PVector p, float weight) {
    float r = weight / (1.25 * (p.mag() + 1.0e-10));
    float x = r * ((p.x - p.y) * (p.x + p.y));
    float y = r * 2.0 * p.x * p.y;
    return new PVector(x,y);
  }
  
  PVector polar(PVector p, float weight) {
    float r = p.mag();
    float theta = atan2(p.x,p.y);
    float x = theta / PI;
    float y = r - 2.0;
    return new PVector(weight * 1.5 * x, weight * 1.5 * y);
  }

  PVector spiral(PVector p, float weight) {
    float r = p.mag() + 1.0e-10;
    float theta = atan2(p.x,p.y);
    float x = weight * 2.0 * (cos(theta) + sin(r)) / r;
    float y = weight * 2.0 * (sin(theta) - cos(r)) / r;
    return new PVector(x,y);
  }
  
  PVector hyperbolic(PVector p, float weight) {
    float r = p.mag() + 1.0e-10;
    float theta = atan2(p.x,p.y);
    float x = weight * sin(theta) / r;
    float y = weight * cos(theta) * r;
    return new PVector(x,y);
  }

  PVector diamond(PVector p, float weight) {
    float r = p.mag();
    float theta = atan2(p.x,p.y);
    float x = weight * 3.0 * sin(theta) * cos(r);
    float y = weight * 3.0 * cos(theta) * sin(r);
    return new PVector(x,y);
  }

  PVector ex(PVector p, float weight) {
    float r = p.mag();
    float theta = atan2(p.x,p.y);
    float xsin = sin(theta + r);
    float ycos = cos(theta - r);
    float x = weight * 0.7 * r * xsin * xsin * xsin;
    float y = weight * 0.7 * r * ycos * ycos * ycos;
    return new PVector(x+y,x-y);
  }
  
  PVector julia(PVector p, float weight) {
    float r = weight * 1.75 * sqrt(p.mag());
    float theta = 0.5 * atan2(p.x,p.y) + (int)(2.0 * random(0,1)) * PI;
    float x = r * cos(theta);
    float y = r * sin(theta);
    return new PVector(x,y);
  }
  
  PVector handkerchief(PVector p, float weight) {
    float r = 0.85*p.mag();
    float theta = atan2(p.x,p.y);
    float x = weight * r * sin(theta + r);
    float y = weight * r * cos(theta - r);
    return new PVector(x,y);
  }
  
  PVector disc(PVector p, float weight) {
    float r = PI*p.mag();
    float theta = 3.0 * weight * atan2(p.x,p.y) / PI;
    float x = theta * sin(r);
    float y = theta * cos(r);
    return new PVector(x,y);
  }
  
  PVector exponential(PVector p, float weight) {
    float r = PI * p.y;
    float sinr = sin(r);
    float cosr = cos(r);
    float d = weight * exp(p.x - 1);      
    return new PVector(d * cosr, d * sinr);  
  }
  
  PVector swirl(PVector p, float weight) {
    float r2 = sq(p.x)+sq(p.y);
    float sinr = sin(r2);
    float cosr = cos(r2);      
    float newX = 0.8 * (sinr * p.x - cosr * p.y);
    float newY = 0.8 * (cosr * p.y + sinr * p.y); 
    return new PVector(weight * newX,weight * newY);
  }

  PVector heart(PVector p, float weight) {
    float r = p.mag();
    float theta = atan2(p.y,p.x);
    float sinr = sin(r * theta);
    float cosr = cos(r * theta);
    return new PVector(weight * r * sinr, -r * weight * cosr); 
  }
  
  PVector power(PVector p, float weight) {
    float theta = atan2(p.y,p.x);
    float sinr = sin(theta);
    float cosr = cos(theta);
    float pow = weight * pow(p.mag(),sinr);
    return new PVector(pow * cosr, pow * sinr); 
  }
  
  PVector eyefish(PVector p, float weight) {
    float r = weight * 4.0  / (p.mag() + 1.0) ;
    return new PVector(r * p.x, r * p.y);  
  }
  
  PVector fisheye(PVector p, float weight) {
    float r = weight * 4.0  / (p.mag() + 1.0) ;
    return new PVector(r * p.y, r * p.x);  
  }

  PVector bubble(PVector p, float weight) {
    float r = weight * 12.0  / (p.x*p.x+p.y*p.y + 4.0) ;
    return new PVector(r * p.x, r * p.y);  
  }

  PVector square(PVector p, float weight) {
    return new PVector(weight * 6.0 * (random(0,1)-0.5), weight * 6.0 * (random(0,1)-0.5));  
  }

  PVector cylinder(PVector p, float weight) {      
    return new PVector(weight*3.0*sin(p.x), weight*p.y);  
  }

  PVector waves(PVector p, float weight) {
    float x = p.x + waves_b * sin(p.y * (1.0 / (waves_c * waves_c) ));
    float y = p.y + waves_e * sin(p.x * (1.0 / (waves_f * waves_f) ));
    return new PVector(weight * x, weight * y);  
  }
 
  PVector popcorn(PVector p, float weight) {
    float x = p.x + popcorn_c * sin(tan(3.0 * p.y));
    float y = p.y + popcorn_f * sin(tan(3.0 * p.x));
    return new PVector(weight * 0.85 * x, weight * 0.85 * y);  
  }
  
  PVector sinusoidal(PVector p, float weight) {
    return new PVector(weight * 3.0 * sin(p.x),3.0 * sin(p.y));
  }
  
  PVector butterfly(PVector p, float weight) {
    float y2 = 2.0 * p.y;
    float r = weight * 1.3029400317411197908970256609023 * sqrt(abs(p.y * p.x) / (1.0e-10 + sq(p.x) + sq(y2)));
    return new PVector(r * p.x,r * y2); 
  }
  
  PVector cosine(PVector p, float weight) {
    float pix = p.x * PI;
    float x = weight * 0.8 * cos(pix) * cosh(p.y);
    float y = -weight * 0.8 * sin(pix) * sinh(p.y); 
    return new PVector(x,y); 
  }
  
  PVector rings(PVector p, float weight) {
    float r = p.mag();
    float theta = atan2(p.x,p.y);
    float r2 = weight * ( (r + rings_c2)%(2.0*rings_c2) + r * (1.0 - rings_c2) );
    float x = r2 * cos(theta);
    float y = r2 * sin(theta); 
    return new PVector(x,y); 
  }
  
  PVector fan(PVector p, float weight) {
    float r = weight * 0.8* p.mag();
    float theta = atan2(p.x,p.y);
    float ang;
    if( abs((theta + fan_f) % fan_cc) > fan_c2)
       ang = theta - fan_c2;
      else
       ang = theta + fan_c2;
    float x = r * cos(ang);
    float y = r * sin(ang); 
    return new PVector(x,y); 
  }
  
  PVector blob(PVector p, float weight) {
    float theta = atan2(p.x,p.y);
    float r = 0.86 * p.mag();
    r = weight * r * (blob_low + blob_bdiff * 0.5 + 0.5 * sin(blob_waves * theta));
    return new PVector(r * sin(theta), r * cos(theta));
  }
  
  PVector pdj(PVector p, float weight) {
    return new PVector( weight * 1.5 * (sin(pdj_a * p.y) - cos(pdj_b * p.x)),
                        weight * 1.5 * (sin(pdj_c * p.x) - cos(pdj_d * p.y)));
  }
  
  PVector bent(PVector p, float weight) {
    float nx = p.x;
    float ny = p.y;
    if(nx < 0) nx = nx + nx;
    if(ny < 0) ny = ny * 0.5;
    return new PVector(weight * nx, weight * ny);
  }
  
  PVector fan2(PVector p, float weight) {
    float r = weight * 0.8 * p.mag();
    float theta = atan2(p.x,p.y);
    float t = theta + fan2_y - floor((theta + fan2_y) / fan2_dx) * fan2_dx;
    float ang;
    if(t > fan2_dx2)
      ang = theta - fan2_dx2;
     else
      ang = theta + fan2_dx2;
    return new PVector(r * sin(ang), r * cos(ang));
  }
  
  PVector rings2(PVector p, float weight) {
    float r = p.mag();
    float theta = atan2(p.x,p.y);
    float d = weight*(r - 2.0 * rings2_val2 * floor( (r+rings2_val2)/(2.0 * rings2_val2)) + r * (1.0 - rings2_val2) );
    return new PVector(d*sin(theta),d*cos(theta));
  }  
    
  PVector perspective(PVector p, float weight) {
    float t = 1.0 / ((perspective_dist - p.y * perspective_vsin) + 1.0e-10);
    float x = weight * perspective_dist * p.x * t;
    float y = weight * perspective_vfcos * p.y * t;
    return new PVector(x,y);
  }    
    
  PVector vnoise(PVector p, float weight) {
    float theta = random(0,1) * TWO_PI;
    float d = weight * random(0,1);
    return new PVector(d*p.x*sin(theta),d*p.y*cos(theta));
  }  
    
  PVector julian(PVector p, float weight) {
    float a = (atan2(p.y,p.x) + TWO_PI * floor(julian_abspower * random(0,1)))/julian_power;
    float r = weight * 2.0 * pow(sq(p.x)+sq(p.y),julian_cpower);
    return new PVector(r*cos(a),r*sin(a));
  }
  
  PVector juliascope(PVector p, float weight) {
    int rnd = (int)(juliascope_abspower * random(0,1));
    float a;
    if(rnd % 2 == 0)
      a = (2 * PI * rnd +atan2(p.y,p.x))/juliascope_power;
     else
      a = (2 * PI * rnd -atan2(p.y,p.x))/juliascope_power;
    float r = weight * 2.0 * pow(sq(p.x)+sq(p.y),juliascope_cpower);
    return new PVector(r*cos(a),r*sin(a));
  }
  
  PVector blur(PVector p, float weight) {
    float a = TWO_PI * random(0,1);
    float r = weight * 3.0 * random(0,1);
    return new PVector(r*cos(a),r*sin(a));
  }
  
  PVector gaussian(PVector p, float weight) {
    float a = TWO_PI * random(0,1);
    float r = weight * 3.0 * (random(0,1) + random(0,1) + random(0,1) + random(0,1) - 2.0);
    return new PVector(r*cos(a),r*sin(a));
  }
  
  PVector realgaussian(PVector p, float weight) {
    float a = TWO_PI * random(0,1);
    float r = weight * 3.0 * randomGaussian();
    return new PVector(r*cos(a),r*sin(a));
  }
  
  PVector radialblur(PVector p, float weight) {
    float rndG = random(0,1) + random(0,1) + random(0,1) + random(0,1) - 2.0;
    float a = atan2(p.y,p.x) + radialblur_spinvar * rndG;
    float r = p.mag();
    float rz = radialblur_zoomvar * rndG - 1.0;
    float x = r * cos(a) + rz * p.x;
    float y = r * sin(a) + rz * p.y;
    return new PVector(weight * x, weight * y);
  }
  
  PVector pie(PVector p, float weight) {
    int sl = (int)(random(0,1) * pie_slices + 0.5);
    float a = pie_rotation + TWO_PI * (sl + random(0,1) * pie_thickness)/pie_slices;
    float r = weight * 3.0 * random(0,1);
    return new PVector(r * cos(a),r * sin(a));
  }
  
  PVector ngon(PVector p, float weight) {
    float rfactor = pow(sq(p.x)+sq(p.y),ngon_pow);
    float theta = atan2(p.y,p.x);
    float phi = theta - (ngon_b * floor(theta/ngon_b));
    if(phi > ngon_b/2.0) phi -= ngon_b;
    
    float amp = 2.0 * weight * (ngon_corners * (1.0 / (cos(phi) + 1.0e-10) -1.0) + ngon_circle);
    amp /= (rfactor + 1e-10);
    
    return new PVector(p.x * amp,p.y * amp);
  }

  PVector curl(PVector p, float weight) {
    float re = 1 + curl_c1 * p.x + curl_c2 * (sq(p.x)-sq(p.y));
    float im = curl_c1 * p.y + curl_c2 * 2 * p.x * p.y;
    float r = weight / (re * re + im * im);
    
    return new PVector(r * (p.x * re + p.y * im),r * (p.y * re - p.x * im));
  }

  PVector wedgejulia(PVector p, float weight) {
    float r = weight * pow(sq(p.x)+sq(p.y),wedgejulia_cn);
    int t_rnd = (int) ((wedgejulia_rN) * random(0,1));
    float a = (atan2(p.y,p.x) + TWO_PI * t_rnd) / wedgejulia_power;
    float c = floor((wedgejulia_count * a + PI) * (1/PI) * 0.5);
    a = a * wedgejulia_cf + c * wedgejulia_angle;
    
    return new PVector(r * cos(a), r * sin(a));
  }
   
  PVector circus(PVector p, float weight) {
    float r = p.mag();
    if(r<1.0)
      r *= circus_size;
     else
      r /= circus_size;
    
    float theta = atan2(p.y,p.x);
    
    return new PVector(weight * r * cos(theta), weight * r * sin(theta));
  }  
 
  PVector rectangles(PVector p, float weight) {
    float x = weight * ((2 * floor(p.x/rectangles_x) + 1)* rectangles_x - p.x);
    float y = weight * ((2 * floor(p.y/rectangles_y) + 1)* rectangles_y - p.y);
    
    return new PVector(x,y);
  }
 
  PVector arch(PVector p, float weight) {
   float a = PI * random(0,1) * arch_weight;
   float sa = sin(a);
   float ca = cos(a);
   return new PVector(weight * sa, weight * sq(sa)/ca);
  }  
    
  PVector tangent(PVector p, float weight) {
    return new PVector(weight * sin(p.x) / (cos(p.y)+1.0e-10), weight * tan(p.y));
  }  

  PVector rays(PVector p, float weight) {
    float a = PI * random(0,1) * rays_weight;
    float r = tan(a) * rays_weight / (p.magSq() + 1.0e-10);
    
    return new PVector(weight * r * cos(p.x), weight * r * sin(p.y));
  }  
 
  PVector blade(PVector p, float weight) {
    float a = random(0,1) * blade_weight * p.mag();
    float sa = sin(a);
    float ca = cos(a);
    
    return new PVector(weight * 0.8 * p.x * (ca + sa), weight * 0.8 * p.x * (ca - sa));
  }  
  
  PVector secant(PVector p, float weight) {
    float a = secant_weight * p.mag();
    float ca = cos(a);
    float icr = 1.0 / (ca + 1.0e-10);
    float y;
    if(ca < 0)
      y = icr + 1.0;
     else
      y = icr - 1.0;
    
    return new PVector(weight * 0.8 * p.x, weight * 0.8* y);
  }  
    
  PVector twintrian(PVector p, float weight) {
    float a = random(0,1) * twintrian_weight * p.mag();
    float sa = sin(a);
    float cla = cos(a) + log(sq(sa));
    if(cla<-30) cla = -30;
    return new PVector(weight * 0.8 * p.x * cla, weight * 0.8 * p.x * (cla - sa * PI));
  }    
  
   PVector cross(PVector p, float weight) {
    float r = sqrt(1.0 / (sq(sq(p.x)-sq(p.y)))+1.0e-10);
    return new PVector(weight * 0.8 * p.x * r,weight * 0.8 * p.y * r);
  }  
   
  PVector disc2(PVector p, float weight) {
    float t = disc2_timespi * (p.x+p.y);
    float r = weight * atan2(p.x,p.y) / PI;
    float x = 0.8 * r * (sin(t) + disc2_cosadd);
    float y = 0.8 * r * (cos(t) + disc2_sinadd);
    return new PVector(x,y);
  }  
 
  PVector supershape(PVector p, float weight) {
    float theta = supershape_pm_4 * atan2(p.y,p.x) + QUARTER_PI;
    float t1 = pow(abs(cos(theta)),supershape_n2);
    float t2 = pow(abs(sin(theta)),supershape_n3);
    float r = weight * ((supershape_rnd * random(0,1) + (1.0 - supershape_rnd) * p.mag()) - supershape_holes) * pow(t1+t2,supershape_pneg1_n1) / p.mag();
    return new PVector( r * p.x, r * p.y);
  }
   
  PVector conic(PVector p, float weight) {
    float r = weight * (random(0,1) - conic_holes) * conic_eccentricity / (1.0 + conic_eccentricity * (p.x / p.mag())) / p.mag();
    return new PVector( r * p.x, r * p.y);
  }  
    
  PVector parabola(PVector p, float weight) {
    float r = sin(p.mag()); 
    return new PVector( weight * parabola_height * sq(r) * random(0,1), weight * parabola_width * cos(p.mag()) * random(0,1) );
  }      
 
  PVector bent2(PVector p, float weight) {
    float x = p.x;
    float y = p.y;
    if(p.x < 0)
      x = p.x * bent2_x;
    if(p.y < 0)
      y = p.y * bent2_y;
    return new PVector( weight * x, weight * y );
  } 
  
  PVector boarders(PVector p, float weight) {
    float roundx = round(p.x);
    float roundy = round(p.y);
    float offsetx = p.x - roundx;
    float offsety = p.y - roundy;

    float x = offsetx * 0.5 + roundx;
    float y = offsety * 0.5 + roundy;
    
    if(random(0,1)<0.75) {
      if(abs(offsetx) >= abs(offsety)) {
        
       if(offsetx >= 0) {
         x += 0.25;
         y += 0.25 * offsety / offsetx; 
       } else {
         x -= 0.25;
         y -= 0.25 * offsety / offsetx; 
       }
        
      } else {
        
        if(offsety >= 0) {
         x += offsetx / offsety * 0.25;
         y += 0.25;
       } else {
         x -= offsetx / offsety * 0.25;
         y -= 0.25; 
       }
        
      }
    }
    return new PVector( weight * x, weight * y );
  } 
   
  PVector bipolar(PVector p, float weight) {
    float r2 = sq(p.x) + sq(p.y);
    float t = r2 + 1.0;
    float x2 = p.x + p.x;
    float y = 0.5 * atan2(p.y+p.y,r2-1.0) + bipolar_ps;
    
    if(y > HALF_PI) 
      y = -HALF_PI + (y + HALF_PI) % PI;
    else 
       if(y < -HALF_PI)
        y = HALF_PI - (HALF_PI - y) % PI; 
    
    float f = t + x2;
    float g = t - x2;
    
    if( (g==0) || (f/g <= 0)) return new PVector(p.x,p.y);
    
    return new PVector( weight * 0.25 * HALF_PI * log(f/g),
                        weight * HALF_PI * y);
  }  

  PVector cell(PVector p, float weight) {
    float x = floor(p.x/cell_size);
    float y = floor(p.y/cell_size);
    
    float dx = p.x - x * cell_size;
    float dy = p.y - y * cell_size;
   
    
    if (y >= 0) {
      if (x >= 0) {
        y *= 2;
        x *= 2;
      }
      else {
        y *= 2;
        x = -(2 * x + 1);
      }
    }
    else {
      if (x >= 0) {
        y = -(2 * y + 1);
        x *= 2;
      }
      else {
        y = -(2 * y + 1);
        x = -(2 * x + 1);
      }
    }
    
    return new PVector(weight * (dx + x * cell_size-cell_size),
                       -weight * (dy + y * cell_size-cell_size));  
  }  
  
  PVector cpow(PVector p,float weight) {
    float a = atan2(p.y,p.x);
    float lnr = 0.5 * log(sq(p.x)+sq(p.y));
    float ang = cpow_vc * a + cpow_vd * lnr + cpow_va * floor(cpow_power * random(0,1));
    float m = weight * exp(cpow_vc * lnr - cpow_vd * a);
    return new PVector(m * cos(ang), m * sin(ang));
  }
  
  PVector fold(PVector p, float weight) {
    return new PVector(weight* (p.x % 3.0) ,weight*(p.y % 3.0));
  }  
    
  PVector foci(PVector p, float weight) {
    float expx = exp(p.x) * 0.5;
    float expnx = 0.25 / expx;
    float tmp = expx + expnx - cos(p.y) + 1.0e-10;
    float r = weight / tmp;
    return new PVector(r * (expx - expnx), r * sin(p.y));
  }  

  PVector loonie(PVector p, float weight) {
    float r2 = sq(p.x)+sq(p.y);
    float w2 = loonie_weight * loonie_weight;
    
    if( (r2 < w2) && r2 != 0) {
      float r = weight * sqrt(w2/r2 -1.0);
      return new PVector(r*p.x,r*p.y);
    } else 
      return new PVector(p.x,p.y);
  }  
  
  PVector polar2(PVector p, float weight) {
    float x = weight * 3/PI * atan2(p.x,p.y);
    float y = weight * 1.5/PI * log(sq(p.x)+sq(p.y));
    return new PVector(x,y);
  }

  PVector scry(PVector p, float weight) {
    float r2 = sq(p.x)*sq(p.y);
    float r = 3.0 / (p.mag() * (r2 + 1.0/scry_weight));
    float x = weight * r * p.x;
    float y = weight * r * p.y;
    return new PVector(x,y);
  }  
  
  PVector vexp(PVector p, float weight) {
    float r = weight * exp(p.x);
    return new PVector(r * cos(p.y),r * sin(p.y));
  }
    
  PVector rotate(PVector p, float angle) {
    float ca = cos(angle);
    float sa = sin(angle);
    return new PVector(ca * p.x - sa * p.y, sa * p.x + ca * p.y);
  }
  
  void draw(PVector p) {
    float i = map(p.x,xmin,xmax,screenl,screenr);
    float j = map(p.y,ymin,ymax,screenl,screenr);
    ellipse(i,j,1,1);
    //ellipse(i,j,0.8,0.8);
  }
  
}


final float cosh(float x) {
  return 0.5 * (exp(x) + exp(-x));
}

final float sinh(float x) {
  return 0.5 * (exp(x) - exp(-x));
}

final float tanh(float x) {
  return sinh(x)/cosh(x);
}

final float safesqrt(float x) {
  return (x<1e-10) ? 0.0 : sqrt(x);
}

final float sgn(float a) {
  if(a == 0.0) return 0.0;
  return a > 0.0 ? 1.0 : -1.0;
}

final float modulate(float amp, float freq, float x) {
   return amp * cos(x * freq * TWO_PI);
 }


final int bytemix (int a, int b) {
    return ((a & 0x5A5A) ^ (b & 0xA5A5));
}

final int bytexim (int a, int b) { // variation...
    return ((a & 0xAAAA) ^ (b & 0x5555));
}

final int byteshf (int a, int b) {
    return ((a << 8) ^ (b >> 8) ) & 0xFFFF;
}

final int bytezhf (int a, int b) { // variation...
    return ((a << 6) ^ (b >> 6)) & 0xFFFF;
}

final int byteprimes (int a, int b) { // variation...
    return ((a * 857 - 4) & 0xFF00 ^ (-b * 977 + 8) & 0x00FF ) ;
}

final float acosh(float a) {
  return log(a + sqrt(a-1) * sqrt(a+1));
}

final float random01() {
  return random(0.0,1.0)<0.5?1.0:0.0;
}

final float M_SQRT5 = 2.2360679774997898;
final float M_PHI = 1.61803398874989484820;
final float FFIVE = 1.0 / M_SQRT5;
final float FNATLOG = log(M_PHI);
final float M_SQRT2 = sqrt(2.0);

final float HSQRT2 = sqrt(2.0) / 2.0;

public static class Jacobi_elliptic_result {
    public float sn, cn, dn;

    public void clear() {
      sn = cn = dn = 0.0;
    }
}

public void Jacobi_elliptic(float uu, float emmc, Jacobi_elliptic_result res) {
    // Code is taken from IROIRO++ library,
    // released under CC share-alike license.

    res.clear();

    // less accurate for faster rendering (still very precise)
    final float CA = 0.0003; // (The accuracy is the square of CA.)

    float a, b, c = 0.0, d = 0.0, em[] = new float[13], en[] = new float[13];
    int bo;
    int l = 0;
    int ii;
    int i;
    // LOGICAL bo

    // main
    float emc = emmc;
    float u = uu;

    if (emc != 0.0) {
      bo = 0;
      if (emc < 0.0)
        bo = 1;

      if (bo != 0) {
        d = 1.0 - emc;
        emc = -emc / d;
        d = sqrt(d);
        u = d * u;
      }
      a = 1.0;
      res.dn = 1.0;

       for(i=0; i<13; i++){// original
      //for (i = 0; i < 8; i++) {
        l = i;
        em[i] = a;
        emc = sqrt(emc);
        en[i] = emc;
        c = 0.5 * (a + emc);
        if (abs(a - emc) <= CA * a)
          break;
        emc = a * emc;
        a = c;
      }

      u = c * u;
      res.sn = sin(u);
      res.cn = cos(u);

      if (res.sn != 0.0) {

        a = res.cn / res.sn;
        c = a * c;
        for (ii = l; ii >= 0; --ii) {
          b = em[ii];
          a = c * a;
          c = res.dn * c;
          res.dn = (en[ii] + a) / (b + a);
          a = c / b;
        }

        a = 1.0 / sqrt(c * c + 1.0);
        if (res.sn < 0.0)
          (res.sn) = -a;
        else
          res.sn = a;
        res.cn = c * (res.sn);
      }
      if (bo != 0) {
        a = res.dn;
        res.dn = res.cn;
        res.cn = a;
        res.sn = (res.sn) / d;
      }
    }
    else {
      res.cn = 1.0 / cosh(u);
      res.dn = res.cn;
      (res.sn) = tanh(u);
    }
  }


//VORONOI 

final static short VORONOI_MAXPOINTS = 25;

float vratio(PVector P, PVector Q, PVector U) {
  PVector tmp = new PVector(P.x, P.y);
  tmp.sub(Q);
  if (tmp.mag() == 0.0) return 1.0;
  PVector tmp2 = new PVector(U.x, U.y);
  tmp2.sub(Q);
  return 2.0 * (tmp2.dot(tmp)) / tmp.magSq();
}

int closest( PVector[] P, int n, PVector U) {
  float d2;
  float d2min = 1.0e10;
  int j=0;
  for (int i=0; i<n; i++) {
    PVector tmp = new PVector(P[i].x, P[i].y);
    tmp.sub(U);
    d2 = tmp.magSq();
    if (d2 < d2min) { 
      d2min = d2; 
      j=i;
    }
  }
  return j;
}

float voronoi( PVector[] P, int n, int q, PVector U) {
  float ratio;
  float ratiomax = -1.0e10;
  for (int i=0; i<n; i++)
    if (i!=q) {
      ratio = vratio(P[i], P[q], U);
      if (ratio > ratiomax) ratiomax = ratio;
    }
  return ratiomax;
}

class Hexes {
  static final float a_hex = 1.0 / 3.0;
  static final float b_hex = 1.7320508075688772935 / 3.0;
  static final float c_hex = -1.0 / 3.0;
  static final float d_hex = 1.7320508075688772935 / 3.0;
  static final float a_cart = 1.5;
  static final float b_cart = -1.5;
  static final float c_cart = 1.7320508075688772935 / 2.0;
  static final float d_cart = 1.7320508075688772935 / 2.0;
  
  final PVector[] cell_choice= { 
    new PVector(-1, -1), 
    new PVector(-1, 0), 
    new PVector(-1, 1), 
    new PVector(0, -1), 
    new PVector(0, 0), 
    new PVector(0, 1), 
    new PVector(1, -1), 
    new PVector(1, 0), 
    new PVector(1, 1)
  };
  
  float cellsize, power, rotate, scale;
  float rotSin, rotCos;
  
  Hexes(float cs, float p, float r, float s) {
    cellsize = cs;
    power = p;
    rotate = r;
    scale = s;
    rotSin = sin(rotate * TWO_PI);
    rotCos = cos(rotate * TWO_PI);
  }
  
  PVector cell_centre(int x, int y, float s) {
    float xx = (a_cart * x + b_cart * y) * s;
    float yy = (c_cart * x + d_cart * y) * s;
    return new PVector(xx,yy);
  }
  
  PVector transform(PVector p, float weight) {
    PVector[] P = new PVector[VORONOI_MAXPOINTS];
    PVector U = p.get();
    
    int Hx = (int)floor((a_hex * U.x + b_hex * U.y) / cellsize);
    int Hy = (int)floor((c_hex * U.x + d_hex * U.y) / cellsize);
    
    int i=0;
    for(int di =-1;di<2;di++) {
      for(int dj =-1;dj<2;dj++) {
        P[i] = cell_centre(Hx+di, Hy+dj, cellsize);
        i++;
      }
    }
    
    int q = closest(P,9,U);
    
    Hx += cell_choice[q].x;
    Hy += cell_choice[q].y;
    
    P[0] = cell_centre(Hx,Hy,cellsize);
    P[1] = cell_centre(Hx,Hy+1,cellsize);
    P[2] = cell_centre(Hx+1,Hy+1,cellsize);
    P[3] = cell_centre(Hx+1,Hy,cellsize);
    P[4] = cell_centre(Hx,Hy-1,cellsize);
    P[5] = cell_centre(Hx-1,Hy-1,cellsize);
    P[6] = cell_centre(Hx-1,Hy,cellsize);
    
    float L1 = voronoi(P,7,0,U);
    PVector Do = U.get();
    Do.sub(P[0]);
    
    float trgL = pow(L1+ 1.0e-10, power) * scale;
    
    PVector V = new PVector(Do.x * rotCos + Do.y * rotSin, -Do.x * rotSin + Do.y * rotCos);
    U = V.get();
    U.add(P[0]);
  
    float L2 = voronoi(P,7,0,U);
  
    float L = (L1 > L2) ? L1:L2;
    float R;
    if(L < 0.5) {
      R = trgL/L1;
    } else {
      if(L>0.8) {
        R = trgL / L2;
      } else {
        R = ((trgL / L1) * (0.8 - L) + (trgL / L2) * (L - 0.5)) / 0.3; 
      }
    }
  
    V.mult(R);
    V.add(P[0]);
    
    V.mult(weight);
    return V;
  }
}

class Crackle {
  final static int CACHE_NUM = 10;
  final static int CACHE_WIDTH = 21;
  
  PVector[] points = new PVector[VORONOI_MAXPOINTS];
  ArrayList<ArrayList<PVector>> c = new ArrayList<ArrayList<PVector>>();

  final PVector[] offset= { 
    new PVector(-1, -1), 
    new PVector(-1, 0), 
    new PVector(-1, 1), 
    new PVector(0, -1), 
    new PVector(0, 0), 
    new PVector(0, 1), 
    new PVector(1, -1), 
    new PVector(1, 0), 
    new PVector(1, 1)
  };
  
  float z, s, d, power, scale;

  Crackle(float zz, float ccellsize, float ddistort, float ppower, float sscale) {
    super();
    z = zz;
    s = ccellsize/2.0;
    power = ppower;
    scale = sscale;
    d = ddistort;
    
    for (int x=-CACHE_NUM; x<=CACHE_NUM; x++) {
      ArrayList<PVector> pv = new ArrayList<PVector>();
      for (int y=-CACHE_NUM; y<=CACHE_NUM; y++) {
        PVector v = position(x, y);
        pv.add(v);
      }
      c.add(pv);
    }
  }
  
  PVector position(int x, int y) {
    PVector E = new PVector(2.5, 2.5, 2.5);
    PVector F = new PVector(30.2, -12.1, 19.8);
    PVector v = new PVector(x, y, z);
    E.add(v);
    F.add(E);
    float xx = (x + d * noise(E.x, E.y, E.z)) * s;
    float yy = (y + d * noise(F.x, F.y, F.z)) * s;
    return new PVector(xx, yy);
  }

  PVector cached_position(int x, int y) {
    if (abs(x) <= CACHE_NUM && abs(y) <= CACHE_NUM) {
      return c.get(x+CACHE_NUM).get(y+CACHE_NUM);
    } else {
      return position(x, y);
    }
  }
  
  PVector transform(PVector p, float weight) {
    float blurr = p.mag();
    float theta = atan2(p.x,p.y);
    PVector U = new PVector(blurr * sin(theta), blurr * cos(theta));
    int xcv = (int)floor(U.x/s);
    int ycv = (int)floor(U.y/s);
    int i=0;
    for (int di=-1; di<2; di++)
      for (int dj=-1; dj<2; dj++) {
        PVector v = cached_position( xcv+di, ycv+dj);
        points[i] = v;
        i++;
      }

    int q = closest(points, 9, U);
    xcv += offset[q].x;
    ycv += offset[q].y;

    i=0;
    for (int di=-1; di<2; di++)
      for (int dj=-1; dj<2; dj++) {
        PVector v = cached_position( xcv+di, ycv+dj);
        points[i] = v;
        i++;
      }

    float L = voronoi(points, 9, 4, U);

    U.sub(points[4]);

    float R = (pow(L+1.0e-10, power) * scale) / (L + 1.0e-10);

    U.mult(R);
    U.add(points[4]);
    U.mult(weight);
    
    return U;
  }
}

private static HashMap<String, ArrayList<PVector>> dlawf_cache = new HashMap<String, ArrayList<PVector>>();

class DLAWF {
  int seed = 667776;
  int maxiter = 4000;
  int buffersize = 800;
  float scale = 4.0;
  
  DLAWF(float sseed, float mmaxiter, float bbuffersize, float sscale) {
    seed = (int)sseed;
    maxiter = (int)mmaxiter;
    buffersize = (int)bbuffersize;
    scale = sscale;
  } 
  
  String makeKey() {
    return buffersize + "_" + maxiter + "_" + seed;
  }
 
  PVector transform(PVector p, float weight) {
    PVector point = getRandomPoint();
    point.mult(weight);
    return point;
  } 
  

  PVector getRandomPoint() {
    ArrayList<PVector> points = getPoints();
    if(points.size() > 0) {
      PVector v = points.get((int)(random(0,1) * points.size()));
      return new PVector(v.x,v.y);
    } else return new PVector(0,0);
  }
  
  ArrayList<PVector> getPoints() {
    String key = makeKey();
    ArrayList<PVector> res = dlawf_cache.get(key);
    if(res == null) {
      short[][] points = calculate();
      res = new ArrayList<PVector>();
      for (int i = 0; i < points.length; i++) {
        for (int j = 0; j < points[i].length; j++) {
          if (points[i][j] != 0) {
            PVector point = new PVector();
            point.x = (((float) (float(i) - buffersize / 2.0)) / (float) buffersize )* scale;
            point.y = (((float) (float(j) - buffersize / 2.0)) / (float) buffersize )* scale;
            res.add(point);
          }
        }
      }
      dlawf_cache.put(key, res);
    }
    return res;
  }
  
  short[][] calculate() {
    int centre = buffersize / 2;
    int size2 = buffersize - 2;
    short q[][] = new short[buffersize][buffersize];
    randomSeed(seed);
    q[centre][centre] = 1;
    float r1 = 3.0;
    float r2 = 3.0 * r1;
    for (int i = 0; i < maxiter; i++) {
      float phi = TWO_PI * random(0,1);
      float ri = r1 * cos(phi);
      float rj = r1 * sin(phi);
      int ci = centre + (int) (ri + 0.5);
      int cj = centre + (int) (rj + 0.5);
      short qt = 0;
      while (qt == 0) {
        float rr = random(0,1);
        rr += rr;
        rr += rr;
        int rd = (int) rr;
        switch (rd) {
          case 0:
            ci++;
            break;
          case 1:
            cj--;
            break;
          case 2:
            ci--;
            break;
          default:
            cj++;
        }
        if ((ci < 1) || (ci > size2) || (cj < 1) || (cj > size2)) {
          qt = 1;
          i--;
        }
        else {
          int sum = q[ci - 1][cj] + q[ci + 1][cj] + q[ci][cj - 1] + q[ci][cj + 1];
          if (sum != 0) {
            q[ci][cj] = qt = 1;
            float r3 = (float) (ci - centre);
            float r4 = (float) (cj - centre);
            r3 *= r3;
            r4 *= r4;
            r3 += r4;
            r3 = sqrt(r3);
            if (r3 > r1) {
              r1 = r3;
              r2 = 2.1 * r1;
            }
          }
          else {
            float r3 = (float) (ci - centre);
            float r4 = (float) (cj - centre);
            r3 *= r3;
            r4 *= r4;
            r3 += r4;
            r3 = sqrt(r3);
            if (r3 > r2) {
              qt = 1;
              i--;
            }
          }
        }
      }
    }
    return q;
  }
  
}