fractex 0.1.0__py3-none-any.whl

fractex/examples/splash.py

@@ -0,0 +1,159 @@
+import sys
+from pathlib import Path
+import numpy as np
+import time
+import itertools
+import argparse
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from fractex import FractalParams, FractalGenerator, InfiniteTexture
+from fractex.interactive import add_preset_arg, resolve_preset
+
+
+def main():
+    try:
+        import matplotlib.pyplot as plt
+        from matplotlib.animation import FuncAnimation
+        import matplotlib as mpl
+    except Exception:
+        print("matplotlib is not available; cannot display splash image.")
+        return
+    
+    parser = argparse.ArgumentParser(description="Fractex splash animation")
+    parser.add_argument("preset", nargs="?", help="Preset name")
+    add_preset_arg(parser, ["marble", "clouds", "wood", "lava", "water"], dest="preset_flag")
+    parser.add_argument("--scale", type=float, default=1.0, help="Render scale multiplier")
+    parser.add_argument("--fps", type=float, default=30.0, help="Target FPS")
+    args = parser.parse_args()
+    
+    params = FractalParams(seed=7, base_scale=0.01, detail_level=2.0)
+    generator = FractalGenerator(params)
+    presets = ["marble", "clouds", "wood", "lava", "water"]
+    textures = {name: InfiniteTexture(generator, name) for name in presets}
+    
+    selected = None
+    if args.preset_flag:
+        selected = resolve_preset(args.preset_flag.strip().lower(), presets)
+    elif args.preset:
+        selected = resolve_preset(args.preset.strip().lower(), presets)
+    
+    try:
+        import tkinter as tk
+        root = tk.Tk()
+        root.withdraw()
+        screen_width = root.winfo_screenwidth()
+        screen_height = root.winfo_screenheight()
+        root.destroy()
+    except Exception:
+        screen_width, screen_height = 1920, 1080
+    
+    mpl.rcParams["toolbar"] = "None"
+    fig, ax = plt.subplots()
+    try:
+        fig.canvas.manager.toolbar.setVisible(False)
+    except Exception:
+        pass
+    dpi = fig.get_dpi()
+    fig.set_size_inches(screen_width / dpi, screen_height / dpi)
+    ax.axis("off")
+    ax.set_title(f"Fractex Splash ({selected or 'auto'})")
+    
+    texture = textures[presets[0]]
+    width = max(64, int(screen_width * max(0.1, args.scale)))
+    height = max(64, int(screen_height * max(0.1, args.scale)))
+    image = texture.generate_tile(0, 0, width, height, zoom=1.0)
+    rgb = image[..., :3]
+    im = ax.imshow(rgb, animated=True, aspect="auto")
+    fig.subplots_adjust(left=0, right=1, top=1, bottom=0)
+    
+    target_fps = max(1.0, args.fps)
+    target_ms = 1000.0 / target_fps
+    render_scale = 1.0
+    detail_level = params.detail_level
+    last_time = time.perf_counter()
+    ema_ms = target_ms
+    phases = {name: 0.0 for name in presets}
+    last_t_base = 0.0
+    
+    def _upscale_nearest(image: np.ndarray, out_w: int, out_h: int) -> np.ndarray:
+        in_h, in_w, _ = image.shape
+        if in_w == out_w and in_h == out_h:
+            return image
+        scale_x = max(1, out_w // in_w)
+        scale_y = max(1, out_h // in_h)
+        up = np.repeat(np.repeat(image, scale_y, axis=0), scale_x, axis=1)
+        return up[:out_h, :out_w, :]
+    
+    def update(frame):
+        nonlocal render_scale, detail_level, last_time, ema_ms, last_t_base
+        t_base = frame / 10.0
+        delta_t = t_base - last_t_base
+        last_t_base = t_base
+        
+        if selected:
+            base_name = selected
+            detail_name = selected
+        else:
+            base_name = presets[(frame // 240) % len(presets)]
+            detail_name = presets[(frame // 240 + 1) % len(presets)]
+        
+        phases[base_name] += delta_t
+        base_texture = textures[base_name]
+        detail_texture = textures[detail_name]
+        t = phases[base_name]
+        t2 = phases[detail_name]
+        
+        base_zoom = 1.0 + t * 0.02
+        detail_zoom = 2.5 + t * 0.05
+        
+        decay = np.exp(-0.01 * t)
+        x0 = np.sin(t * 0.12) * 5.0 * decay
+        y0 = np.cos(t * 0.10) * 5.0 * decay
+        x1 = np.sin(t2 * 0.22 + 1.2) * 2.0 * decay
+        y1 = np.cos(t2 * 0.18 + 0.7) * 2.0 * decay
+        
+        now = time.perf_counter()
+        dt_ms = (now - last_time) * 1000.0
+        last_time = now
+        ema_ms = ema_ms * 0.9 + dt_ms * 0.1
+        
+        if ema_ms > target_ms * 1.1:
+            render_scale = max(0.4, render_scale * 0.9)
+            detail_level = max(0.6, detail_level * 0.9)
+        elif ema_ms < target_ms * 0.9:
+            render_scale = min(1.0, render_scale * 1.05)
+            detail_level = min(3.0, detail_level * 1.05)
+        
+        generator.params.detail_level = detail_level
+        render_w = max(64, int(width * render_scale))
+        render_h = max(64, int(height * render_scale))
+        
+        base = base_texture.generate_tile(x0, y0, render_w, render_h, zoom=base_zoom)[..., :3]
+        detail = detail_texture.generate_tile(x1, y1, render_w, render_h, zoom=detail_zoom)[..., :3]
+        
+        depth = 0.35 + 0.15 * np.sin(t * 0.2)
+        rgb_frame = np.clip(base * (1.0 - depth) + detail * depth, 0, 1)
+        
+        tint = 0.6 + 0.4 * np.sin(t * 0.2)
+        rgb_frame = np.clip(rgb_frame * np.array([1.0, tint, 0.9]), 0, 1)
+        rgb_frame = _upscale_nearest(rgb_frame, width, height)
+        im.set_array(rgb_frame)
+        return (im,)
+    
+    anim = FuncAnimation(
+        fig,
+        update,
+        frames=itertools.count(),
+        interval=0,
+        blit=True,
+        repeat=True,
+        cache_frame_data=False,
+    )
+    plt.show(block=True)
+
+
+if __name__ == "__main__":
+    main()

fractex/examples/terrain.py

@@ -0,0 +1,76 @@
+import sys
+from pathlib import Path
+import numpy as np
+import argparse
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+EXAMPLES_DIR = Path(__file__).resolve().parent
+if str(EXAMPLES_DIR) not in sys.path:
+    sys.path.insert(0, str(EXAMPLES_DIR))
+
+from fractex.texture_blending import TerrainTextureBlender
+from fractex.simplex_noise import SimplexTextureGenerator
+from _output import save_ppm
+from fractex.interactive import add_interactive_args, InteractiveConfig, run_interactive
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Terrain example")
+    add_interactive_args(parser)
+    args = parser.parse_args()
+    terrain_blender = TerrainTextureBlender(seed=42)
+    tex_gen = SimplexTextureGenerator(seed=42)
+    
+    size = 256
+    terrain_base = tex_gen.generate_terrain(size, size)
+    height_map = terrain_base[..., 0]
+    
+    grass_texture = tex_gen.generate_grass(size, size)
+    dirt_texture = tex_gen.generate_wood(size, size)
+    rock_texture = tex_gen.generate_marble(size, size)
+    snow_texture = tex_gen.generate_clouds(size, size)
+    
+    terrain = terrain_blender.create_terrain_material(
+        height_map=height_map,
+        texture_layers={
+            "grass": grass_texture,
+            "dirt": dirt_texture,
+            "rock": rock_texture,
+            "snow": snow_texture,
+        },
+        biome="mountain",
+        custom_params={
+            "height_ranges": [(0.0, 0.3), (0.2, 0.5), (0.4, 0.8), (0.7, 1.0)],
+            "slope_thresholds": [0.4, 0.6, 0.8],
+        },
+    )
+    
+    grass_detail = tex_gen.generate_grass(size, size)
+    rock_detail = tex_gen.generate_marble(size, size)
+    moss_detail = tex_gen.generate_clouds(size, size)
+    
+    terrain_detailed = terrain_blender.add_detail_layers(
+        terrain,
+        detail_textures=[grass_detail, rock_detail, moss_detail],
+        scale_factors=[2.0, 1.5, 3.0],
+        blend_modes=["overlay", "multiply", "screen"],
+    )
+    
+    print("Terrain material:", terrain.shape, terrain.min(), terrain.max())
+    print("Terrain detailed:", terrain_detailed.shape)
+    save_ppm(terrain_detailed, EXAMPLES_DIR / "output" / "terrain_detailed.ppm")
+    
+    if args.interactive:
+        config = InteractiveConfig.from_args(args, title="Terrain (interactive)")
+        
+        def render_frame(t, w, h):
+            tex = SimplexTextureGenerator(seed=42)
+            return tex.generate_terrain(w, h, scale=0.004 + 0.002 * np.sin(t * 0.1))[..., :3]
+        
+        run_interactive(render_frame, config)
+
+
+if __name__ == "__main__":
+    main()

fractex/examples/underwater.py

@@ -0,0 +1,94 @@
+import sys
+from pathlib import Path
+import numpy as np
+import argparse
+from dataclasses import dataclass
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+EXAMPLES_DIR = Path(__file__).resolve().parent
+if str(EXAMPLES_DIR) not in sys.path:
+    sys.path.insert(0, str(EXAMPLES_DIR))
+
+from fractex.volume_scattering import UnderwaterScattering
+from fractex.volume_textures import VolumeTextureGenerator3D
+from _output import save_ppm, save_mp4
+from fractex.interactive import add_interactive_args, InteractiveConfig, run_interactive
+
+
+@dataclass
+class Player:
+    position: np.ndarray
+    look_at: np.ndarray
+
+
+def compute_bioluminescence(plankton, position, time_of_day: float) -> np.ndarray:
+    strength = 1.0 if time_of_day > 0.8 or time_of_day < 0.2 else 0.0
+    glow = plankton.data[..., 3].mean() if plankton.data is not None else 0.0
+    return np.ones((64, 96, 3), dtype=np.float32) * glow * strength
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Underwater example")
+    add_interactive_args(parser)
+    args = parser.parse_args()
+    underwater_renderer = UnderwaterScattering()
+    
+    particle_generator = VolumeTextureGenerator3D(seed=42)
+    plankton = particle_generator.generate_clouds_3d(
+        width=32, height=32, depth=32,
+        scale=0.1, density=0.1, detail=2
+    )
+    
+    player = Player(
+        position=np.array([0.0, -5.0, 0.0]),
+        look_at=np.array([0.0, -5.0, 1.0])
+    )
+    water_level = 0.0
+    time_of_day = 0.9
+    is_night = time_of_day > 0.8 or time_of_day < 0.2
+    
+    frames = []
+    for t in [0.6, 0.7, 0.8, 0.85, 0.9, 0.95, 0.98, 0.75]:
+        is_night = t > 0.8 or t < 0.2
+        underwater_image = underwater_renderer.render_underwater(
+            camera_pos=player.position,
+            view_direction=player.look_at - player.position,
+            water_surface_height=water_level,
+            image_size=(192, 128),
+            max_depth=30.0
+        )
+        if is_night:
+            bioluminescence = compute_bioluminescence(
+                plankton, player.position, t
+            )
+            underwater_image = np.clip(underwater_image + bioluminescence * 0.3, 0, 1)
+        frames.append(underwater_image)
+    
+    underwater_image = frames[-1]
+    print("Underwater image:", underwater_image.shape)
+    save_ppm(underwater_image, EXAMPLES_DIR / "output" / "underwater.ppm")
+    save_mp4(frames, EXAMPLES_DIR / "output" / "underwater.mp4", fps=8, stretch=True)
+    
+    if args.interactive:
+        config = InteractiveConfig.from_args(args, title="Underwater (interactive)")
+        
+        def render_frame(t, w, h):
+            underwater_image = underwater_renderer.render_underwater(
+                camera_pos=player.position,
+                view_direction=player.look_at - player.position,
+                water_surface_height=water_level,
+                image_size=(w, h),
+                max_depth=20.0
+            )
+            if t % 10 > 5:
+                bioluminescence = compute_bioluminescence(plankton, player.position, 0.9)
+                underwater_image = np.clip(underwater_image + bioluminescence * 0.3, 0, 1)
+            return underwater_image
+        
+        run_interactive(render_frame, config)
+
+
+if __name__ == "__main__":
+    main()

fractex/examples/underwater_volkano.py

@@ -0,0 +1,112 @@
+import sys
+from pathlib import Path
+import numpy as np
+import argparse
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+EXAMPLES_DIR = Path(__file__).resolve().parent
+if str(EXAMPLES_DIR) not in sys.path:
+    sys.path.insert(0, str(EXAMPLES_DIR))
+
+from fractex.dynamic_textures_3d import DynamicTextureGenerator3D, DynamicTextureType, DynamicTextureState
+from _output import save_ppm_sequence, save_mp4
+from fractex.interactive import add_interactive_args, InteractiveConfig, run_interactive
+
+
+def blend_lava_and_water(lava_state: DynamicTextureState, water_state: DynamicTextureState) -> DynamicTextureState:
+    blended = np.clip(lava_state.data * 0.6 + water_state.data * 0.4, 0, 1)
+    return DynamicTextureState(time=water_state.time, data=blended)
+
+
+def add_bubbles_to_water(lava_state: DynamicTextureState, water_state: DynamicTextureState) -> DynamicTextureState:
+    if lava_state.temperature_field is None or water_state.data is None:
+        return water_state
+    hot_mask = lava_state.temperature_field > 800
+    bubbles = np.zeros_like(water_state.data[..., 0])
+    bubbles[hot_mask] = np.clip(lava_state.temperature_field[hot_mask] / 1200.0, 0, 1) * 0.1
+    water_state.data[..., 0] = np.clip(water_state.data[..., 0] + bubbles, 0, 1)
+    return water_state
+
+
+def create_underwater_volcano():
+    """Создание подводного вулкана с лавой и пузырями"""
+    lava_generator = DynamicTextureGenerator3D(
+        dimensions=(32, 32, 32),
+        texture_type=DynamicTextureType.LAVA_FLOW,
+        seed=42
+    )
+    
+    water_generator = DynamicTextureGenerator3D(
+        dimensions=(32, 32, 32),
+        texture_type=DynamicTextureType.WATER_FLOW,
+        seed=123
+    )
+    
+    def safe_update(generator: DynamicTextureGenerator3D) -> DynamicTextureState:
+        try:
+            return generator.update()
+        except Exception as exc:
+            print(f"Simulation update skipped: {exc}")
+            depth, height, width = generator.dimensions
+            data = np.zeros((depth, height, width, 4), dtype=np.float32)
+            return DynamicTextureState(time=0.0, data=data)
+    
+    states = []
+    for _ in range(12):
+        lava_state = safe_update(lava_generator)
+        water_state = safe_update(water_generator)
+        water_state = add_bubbles_to_water(lava_state, water_state)
+        blended_state = blend_lava_and_water(lava_state, water_state)
+        states.append(blended_state)
+    
+    return states
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Underwater volcano example")
+    add_interactive_args(parser)
+    args = parser.parse_args()
+    
+    states = create_underwater_volcano()
+    print("Frames:", len(states), "state shape:", states[-1].data.shape)
+    frames = []
+    for state in states:
+        mid = state.data.shape[0] // 2
+        frames.append(state.data[mid])
+    save_ppm_sequence(
+        frames,
+        EXAMPLES_DIR / "output" / "underwater_volkano_frames",
+        prefix="volkano",
+        stretch=True,
+    )
+    save_mp4(
+        frames,
+        EXAMPLES_DIR / "output" / "underwater_volkano.mp4",
+        fps=12,
+        stretch=True,
+    )
+    
+    if args.interactive:
+        config = InteractiveConfig.from_args(args, title="Underwater Volcano (interactive)")
+        lava_generator = DynamicTextureGenerator3D(
+            dimensions=(32, 32, 32),
+            texture_type=DynamicTextureType.LAVA_FLOW,
+            seed=42
+        )
+        water_generator = DynamicTextureGenerator3D(
+            dimensions=(32, 32, 32),
+            texture_type=DynamicTextureType.WATER_FLOW,
+            seed=123
+        )
+        
+        def render_frame(t, w, h):
+            lava_state = lava_generator.update()
+            water_state = water_generator.update()
+            water_state = add_bubbles_to_water(lava_state, water_state)
+            blended_state = blend_lava_and_water(lava_state, water_state)
+            mid = blended_state.data.shape[0] // 2
+            return blended_state.data[mid, :, :, :3]
+        
+        run_interactive(render_frame, config)