Add fractal effect

Lux/lux_files/CA_choices.json

@@ -433,6 +433,16 @@
             "default_value": false,
             "value": { "functions": [ "flip_y_toggle" ] }
         },
+        {
+            "name": "scale_slider",
+            "type": "slider_float",
+            "label": "Scale",
+            "description": "Scale factor for the target image.",
+            "min": 0.0,
+            "max": 3.0,
+            "default_value": 1.0,
+            "step": 0.001
+        },
         {
             "name": "angle_slider",
             "type": "slider_float",
@@ -467,6 +477,36 @@
             "default_value": 0.0,
             "step": 1.0
         },
+        {
+            "name": "complex_power_slider",
+            "type": "slider_float",
+            "label": "Complex Power",
+            "description": "Power for the complex transformation.",
+            "min": -4.0,
+            "max": 4.0,
+            "default_value": 2.0,
+            "step": 0.01
+        },
+        {
+            "name": "complex_power_cx_slider",
+            "type": "slider_float",
+            "label": "Seed X",
+            "description": "X coordinate for the complex power offset.",
+            "min": -2.0,
+            "max": 2.0,
+            "default_value": -1.0,
+            "step": 0.01
+        },
+        {
+            "name": "complex_power_cy_slider",
+            "type": "slider_float",
+            "label": "Seed Y",
+            "description": "Y coordinate for the complex power offset.",
+            "min": -2.0,
+            "max": 2.0,
+            "default_value": 0.0,
+            "step": 0.01
+        },
         {
             "name": "warp_menu_generator",
             "type": "generator_int",
@@ -484,7 +524,7 @@
             "tool": "pull_down",
             "label": "Warp Effect",
             "description": "Choose a warp effect to apply to the target image.",
-            "items": [ "Flip", "Rotate" ],
+            "items": [ "Flip", "Rotate", "Fractal" ],
             "affects_widget_groups": true,
             "default_choice": 0,
             "choice": { "functions": [ "warp_menu_generator" ] }
@@ -501,6 +541,12 @@
             "a": { "functions": [ "warp_menu" ] },
             "b": 1
         },
+        {
+            "name": "warp_menu_2",
+            "type": "equal_int_condition",
+            "a": { "functions": [ "warp_menu" ] },
+            "b": 2
+        },
         {
             "name": "targ_dim",
             "type": "buffer_dim_fn",
@@ -721,6 +767,11 @@
             "name": "position fill",
             "type": "eff_position_fill_vec2f"
         },
+        {
+            "name": "scale vector field",
+            "type": "eff_scale_vectors_vec2f",
+            "scale": { "functions": [ "scale_slider" ] }
+        },
         {
             "name": "radial",
             "type": "eff_radial_vec2f"
@@ -745,10 +796,18 @@
             "type": "eff_rotate_vectors_vec2f",
             "angle": { "functions": [ "angle_slider" ] }
         },
+        {
+            "name": "Complex Power",
+            "type": "eff_complex_power_vec2f",
+            "p": { "functions": [ "complex_power_slider" ] },
+            "cx": { "functions": [ "complex_power_cx_slider" ] },
+            "cy": { "functions": [ "complex_power_cy_slider" ] },
+            "scale": { "functions": [ "scale_slider" ] }
+        },
         {
             "name": "Warp chooser",
             "type": "eff_chooser",
-            "effects": [ "Flip", "Rotate" ],
+            "effects": [ "Flip", "Rotate", "Complex Power" ],
             "choice": { "functions": [ "warp_menu" ] }
         },
         {
@@ -772,7 +831,7 @@
             "dim": { "functions": [ "targ_dim" ] },
             "type": "vector_field",
             "mode": "ephemeral",
-            "effects": [ "position fill", "Warp chooser" ]
+            "effects": [ "position fill", "scale vector field", "Warp chooser" ]
         },
         {
             "name": "Target Warp",
@@ -798,7 +857,7 @@
         },
         { 
             "name": "targ_image_group",
-            "widgets": [ "targ_image_menu", "invert_target_switch", "target_color_angle_slider", "warp_menu" ]
+            "widgets": [ "targ_image_menu", "invert_target_switch", "target_color_angle_slider", "warp_menu", "scale_slider" ]
         },
         {
             "name": "flip_group",
@@ -810,6 +869,11 @@
             "conditions": [ "warp_menu_1" ],
             "widgets": [ "angle_slider" ]
         },
+        {
+            "name": "complex_power_group",
+            "conditions": [ "warp_menu_2" ],
+            "widgets": [ "complex_power_slider", "complex_power_cx_slider", "complex_power_cy_slider", "complex_power_scale_slider" ]
+        },
         {
             "name": "source_image_group",
             "widgets": [ "source_image_menu" ]

Lux/lux_react/src/components/JenSlider.jsx

@@ -299,8 +299,13 @@ function JenSlider({ json, width }) {
         if (json.type === 'slider_int' || json.type === 'range_slider_int') {
             return parseInt(val);
         } else {
-            const rounded = parseFloat(val).toFixed(1);
-            return rounded.endsWith('.0') ? rounded.slice(0, -2) : rounded;
+            const num = Number(val);
+            if (!Number.isFinite(num)) return '';
+            const precision = 3;
+            const fixed = num.toFixed(precision);
+            // strip trailing zeros and optional trailing decimal point
+            const trimmed = fixed.replace(/\.?0+$/, '');
+            return trimmed;
         }
     }, [json.type]);
 

Lux/src/any_effect.hpp

@@ -46,6 +46,7 @@ template< class T > struct eff_concentric;
 template< class T > struct eff_rotational;
 template< class T > struct eff_spiral;
 template< class T > struct eff_fermat_spiral;
+template< class T > struct eff_complex_power;
 template< class T > struct eff_vortex;
 template< class T > struct eff_turbulent;
 template< class T > struct eff_kaleidoscope;
@@ -164,6 +165,7 @@ typedef std::variant <
     std::shared_ptr< eff_rotational< vec2f > >,
     std::shared_ptr< eff_spiral< vec2f > >,
     std::shared_ptr< eff_fermat_spiral< vec2f > >,
+    std::shared_ptr< eff_complex_power< vec2f > >,
     std::shared_ptr< eff_vortex< vec2f > >,
     std::shared_ptr< eff_turbulent< vec2f > >,
     std::shared_ptr< eff_kaleidoscope< vec2f > >,

Lux/src/effect.cpp

@@ -397,6 +397,18 @@ template< class T > void eff_fermat_spiral< T >::operator () ( any_buffer_pair_p
 
 template class eff_fermat_spiral< vec2f >;
 
+template< class T > void eff_complex_power< T >::operator () ( any_buffer_pair_ptr& buf, element_context& context )
+{
+    p(context);
+    cx(context);
+    cy(context);
+    scale(context);
+    vf_tools tools( get_image< T >( buf ) );
+    tools.complex_power( *p, { *cx, *cy }, *scale );
+}
+
+template class eff_complex_power< vec2f >;
+
 template< class T > void eff_vortex< T >::operator () ( any_buffer_pair_ptr& buf, element_context& context )
 {
     if (std::holds_alternative< vbuf_ptr>(buf)) 

Lux/src/effect.hpp

@@ -377,6 +377,20 @@ template< class T > struct eff_fermat_spiral {
 
 typedef eff_fermat_spiral< vec2f > eff_fermat_spiral_vec2f;
 
+template< class T > struct eff_complex_power {
+    harness< float > p;
+    harness< float > cx;
+    harness< float > cy;
+    harness< float > scale;
+
+    void operator () ( any_buffer_pair_ptr& buf, element_context& context );
+
+    eff_complex_power( float p_init = 2.0f, float cx_init = 0.0f, float cy_init = 0.0f, float scale_init = 1.0f ) : 
+        p( p_init ), cx( cx_init ), cy( cy_init ), scale( scale_init ) {}
+};
+
+typedef eff_complex_power< vec2f > eff_complex_power_vec2f;
+
 template< class T > struct eff_vortex {
     harness< float > diameter;   // float - Overall size of vortex
     harness< float > soften;     // float - Avoids a singularity in the center of vortex

Lux/src/scene.cpp

@@ -107,18 +107,11 @@ void effect_list::resize( vec2i new_dim ) {
 void effect_list::update( scene& s ) {
     // create dummy context
     element_context context( s, buf );
-    /*if( name == "Self") {
-        any_buffer_pair_ptr buf = context.s.buffers[ name ];
-        vec2i val;
-        std::visit( [&]( auto& b ) { val = b->get_image().get_dim(); }, buf );
-        std::cout << "effect_list " << name << " update() - buffer dim " << val.x << " " << val.y << std::endl;
-    }*/
 
     if( self_generated ) {
         vec2i old_dim = *dim;
         dim( context );
         vec2i new_dim = *dim;
-        //if( name == "warp_vf" ) std::cout << "effect_list " << name << " update() - new dim " << new_dim.x << " " << new_dim.y << std::endl;
         if( new_dim != old_dim ) {
             resize( new_dim );
             rendered = false;

Lux/src/scene_io.cpp

@@ -821,6 +821,7 @@ void scene_reader::read_effect( const json& j ) {
     EFF( eff_rotational_vec2f ) HARNESSE( center ) END_EFF()
     EFF( eff_spiral_vec2f ) HARNESSE( center ) HARNESSE( angle ) END_EFF()
     EFF( eff_fermat_spiral_vec2f ) HARNESSE( c ) END_EFF()
+    EFF( eff_complex_power_vec2f ) HARNESSE( p ) HARNESSE( cx ) HARNESSE( cy ) HARNESSE( scale ) END_EFF()
     EFF( eff_vortex_vec2f ) HARNESSE( diameter ) HARNESSE( soften ) HARNESSE( intensity ) HARNESSE( center_orig ) 
                             READE( revolving ) HARNESSE( velocity ) HARNESSE( center_of_revolution ) END_EFF()
     EFF( eff_turbulent_vec2f ) HARNESSE( n ) HARNESSE( bounds ) HARNESSE( scale_factor ) 

Lux/src/vector_field.cpp

@@ -172,6 +172,17 @@ void vf_tools::fermat_spiral(const float& c)
     }
 }
 
+void vf_tools::complex_power( const float& p, const vec2f& c, float scale ) {
+    auto& base = img.mip[ 0 ];
+    vec2f z;
+    float r, theta;
+    if( scale == 0.0f ) scale = 1.0f;
+    for( auto& v : base ) {
+        v = ( ::complex_power( v, p ) + c ) / scale;
+    }
+    img.mip_utd = false;
+}
+
 void vf_tools::vortex( const ::vortex& vort, const float& t ) {
     vec2f center= vort.center_orig;
     if( vort.revolving ) center = vort.center_of_revolution + linalg::rot( vort.velocity * t * TAU, vort.center_orig - vort.center_of_revolution );

Lux/src/vector_field.hpp

@@ -107,6 +107,7 @@ class vf_tools {
     void rotation(   const vec2f& center = { 0.0f, 0.0f } );
     void spiral(     const vec2f& center = { 0.0f, 0.0f }, const float& cscale = 1.0f, const float& rscale = 1.0f );
     void fermat_spiral(const float& c);
+    void complex_power( const float& p, const vec2f& c = { 0.0f, 0.0f }, float scale = 1.0f );
 
     void vortex( const ::vortex& vort, const float& t = 0.0f );
     void turbulent( vortex_field& f,  const float& t = 0.0f );