Mã nguồn

1extern crate nalgebra as na;2use na::{Vector3};34use rayon::prelude::*;56use sha3::{Digest, Sha3_256};78pub struct Sha3RandomByteStream {9    hasher: Sha3_256,10    seed: Vec<u8>,11    buffer: Vec<u8>,12    index: usize,13}1415impl Sha3RandomByteStream {16    pub fn new(seed: &Vec<u8>) -> Self {17        let mut hasher = Sha3_256::new();18        let cloned_seed = seed.clone();19        hasher.update(seed);20        let buffer = hasher.clone().finalize_reset().to_vec();21        Self {22            hasher,23            seed: cloned_seed,24            buffer,25            index: 0,26        }27    }2829    pub fn next_byte(&mut self) -> u8 {30        if self.index >= self.buffer.len() {31            self.hasher.update(&self.seed);32            self.hasher.update(&self.buffer);33            self.buffer = self.hasher.finalize_reset().to_vec();34            self.index = 0;35        }3637        let byte = self.buffer[self.index];38        self.index += 1;39        byte40    }4142    pub fn next_u64(&mut self) -> u64 {43        let mut bytes = [0u8; 8];44        for i in 0..8 {45            bytes[i] = self.next_byte();46        }47        u64::from_le_bytes(bytes)48    }4950    pub fn next_f64(&mut self) -> f64 {51        let value: u64 = self.next_u64();52        let max_value = u64::MAX;53        (value as f64) / (max_value as f64)54    }5556    pub fn gen_range(&mut self, min: f64, max: f64) -> f64 {57        let num = self.next_f64();58        let range = max - min;59        let value = num * range + min;60        value61    }6263    pub fn random_mass(&mut self) -> f64 {64        self.gen_range(100.0, 300.0)65    }6667    pub fn random_location(&mut self) -> f64 {68        let n = 1500.0;69        self.gen_range(-n, n)70    }7172    pub fn random_velocity(&mut self) -> f64 {73        let n: f64 = 25.0;74        self.gen_range(-n, n)75    }767778}7980#[derive(Clone)]81struct Body {82    mass: f64,83    position: Vector3<f64>,84    velocity: Vector3<f64>,85    acceleration: Vector3<f64>,86}8788const G: f64 = 9.8;8990impl Body {91    fn new(mass: f64, position: Vector3<f64>, velocity: Vector3<f64>) -> Body {92        Body {93            mass,94            position,95            velocity,96            acceleration: Vector3::zeros(),97        }98    }99100    fn update_acceleration(&mut self, other_mass: f64, other_position: Vector3<f64>) {101        let dir: Vector3<f64> = self.position - other_position;102        let mag = dir.norm();103        self.acceleration += -G * other_mass * dir / (mag * mag * mag);104    }105106    fn reset_acceleration(&mut self) {107        self.acceleration = Vector3::zeros();108    }109}110111fn verlet_step(bodies: &mut [Body], dt: f64) {112    for i in 0..bodies.len() {113        bodies[i].reset_acceleration();114        for j in 0..bodies.len() {115            if i != j {116                bodies[i].update_acceleration(bodies[j].mass, bodies[j].position);117            }118        }119    }120121    for i in 0..bodies.len() {122        bodies[i].position = bodies[i].position + bodies[i].velocity * dt + 0.5 * bodies[i].acceleration * (dt * dt);123    }124125    for i in 0..bodies.len() {126        for j in 0..bodies.len() {127            if i != j {128                bodies[i].update_acceleration(bodies[j].mass, bodies[j].position);129            }130        }131    }132133    for i in 0..bodies.len() {134        bodies[i].velocity = bodies[i].velocity + 0.5 * bodies[i].acceleration * dt;135    }136}137138use std::f64::{INFINITY, NEG_INFINITY};139140use image::{ImageBuffer, Rgb};141use imageproc::drawing::draw_filled_circle_mut;142143use palette::{FromColor, Hsl, Srgb};144145fn get_single_color_walk(rng: &mut Sha3RandomByteStream, len: usize) -> Vec<Rgb<u8>> {146    let mut colors = Vec::new();147    let mut hue = rng.gen_range(0.0, 360.0);148    for _ in 0..len {149        if rng.next_byte() & 1 == 0 {150            hue += 0.1;151        } else {152            hue -= 0.1;153        }154        if hue < 0.0 {155            hue += 360.0;156        }157        if hue > 360.0 {158            hue -= 360.0;159        }160        let hsl = Hsl::new(hue, 1.0, 0.5);161        let my_new_rgb = Srgb::from_color(hsl);162163        let r = (my_new_rgb.red * 255.0) as u8;164        let g = (my_new_rgb.green * 255.0) as u8;165        let b = (my_new_rgb.blue * 255.0) as u8;166167        let line_color: Rgb<u8> = Rgb([r, g, b]);168        colors.push(line_color);169    }170    colors171}172173fn get_3_colors(rng: &mut Sha3RandomByteStream, len: usize) -> Vec<Vec<Rgb<u8>>> {174    let mut colors = Vec::new();175    for _ in 0..3 {176        let c = get_single_color_walk(rng, len);177        colors.push(c);178    }179    colors180}181182fn plot_positions(183  positions: &Vec<Vec<Vector3<f64>>>,184  frame_size: u32,185  snake_len: f64,186  init_len: usize,187  hide: &Vec<bool>,188  colors: &Vec<Vec<Rgb<u8>>>,189  frame_interval: usize190) -> Vec<ImageBuffer<Rgb<u8>, Vec<u8>>> {191    let background_color = Rgb([0u8, 0u8, 0u8]);192193    // Find the minimum and maximum coordinates for x and y194    let (mut min_x, mut min_y) = (INFINITY, INFINITY);195    let (mut max_x, mut max_y) = (NEG_INFINITY, NEG_INFINITY);196197    let white_color = Rgb([255, 255, 255]);198199    for body_idx in 0..positions.len() {200        if hide[body_idx] {201            continue;202        }203        for step in 0..positions[body_idx].len() {204            let x = positions[body_idx][step][0];205            let y = positions[body_idx][step][1];206            if x < min_x { min_x = x; }207            if y < min_y { min_y = y; }208            if x > max_x { max_x = x; }209            if y > max_y { max_y = y; }210        }211    }212    // TODO: make sure that scaling is equal in both directions213    let x_range = max_x - min_x;214    let y_range = max_y - min_y;215    let x_center = (min_x + max_x) / 2.0;216    let y_center = (min_y + max_y) / 2.0;217    let mut range = if x_range > y_range {218        x_range219    } else {220        y_range221    };222    min_x = x_center - (range / 2.0) * 1.1;223    max_x = x_center + (range / 2.0) * 1.1;224    min_y = y_center - (range / 2.0) * 1.1;225    range = max_x - min_x;226227    let mut frames = Vec::new();228229    let mut snake_end: usize = frame_interval;230231    loop {232        let mut img = ImageBuffer::from_fn(frame_size, frame_size, |_, _| background_color);233234        let mut snake_starts: [usize; 3] = [0, 0, 0];235236        for body_idx in 0..positions.len() {237            if hide[body_idx] {238                continue;239            }240241            let mut total_dist: f64 = 0.0;242            let mut idx = snake_end;243            loop {244                if idx <= 1 || total_dist > range * snake_len {245                    break;246                }247                let x1 = positions[body_idx][idx][0];248                let y1 = positions[body_idx][idx][1];249                let x2 = positions[body_idx][idx - 1][0];250                let y2 = positions[body_idx][idx - 1][1];251                let dist = ((x1 - x2).powi(2) + (y1 - y2).powi(2)).sqrt();252                total_dist += dist;253                idx -= 1;254            }255            snake_starts[body_idx] = idx;256257            for i in snake_starts[body_idx]..snake_end {258                let x1 = positions[body_idx][i][0];259                let y1 = positions[body_idx][i][1];260261                // Scale and shift positions to fit within the image dimensions262                let x1p = (((x1 - min_x) / range) * (frame_size as f64)).round();263                let y1p = (((y1 - min_y) / range) * (frame_size as f64)).round();264265                draw_filled_circle_mut(&mut img, (x1p as i32, y1p as i32), 6, colors[body_idx][i]);266                //draw_filled_circle_mut(&mut img, (x1p as i32, y1p as i32), 6, white_color);267            }268        }269270        let mut blurred_img = imageproc::filter::gaussian_blur_f32(&img, 6.0);271        for body_idx in 0..positions.len() {272            if hide[body_idx] {273                continue;274            }275276            for i in snake_starts[body_idx]..snake_end {277278                let x1 = positions[body_idx][i][0];279                let y1 = positions[body_idx][i][1];280281                // Scale and shift positions to fit within the image dimensions282                let x1p = ((x1 - min_x) / range * (frame_size as f64 - 1.0)).round();283                let y1p = ((y1 - min_y) / range * (frame_size as f64 - 1.0)).round();284285286                draw_filled_circle_mut(&mut blurred_img, (x1p as i32, y1p as i32), 1, white_color);287            }288        }289290        if snake_end >= init_len {291            frames.push(imageproc::filter::gaussian_blur_f32(&blurred_img, 1.0));292        }293        snake_end += frame_interval;294        if snake_end >= positions[0].len() {295            break;296        }297    }298299    return frames;300301}302303extern crate rustfft;304use rustfft::FftPlanner;305use rustfft::num_complex::Complex;306307fn fourier_transform(input: &[f64]) -> Vec<Complex<f64>> {308    let n = input.len();309310    // Create an FFT planner311    let mut planner = FftPlanner::new();312    let fft = planner.plan_fft_forward(n);313314    // Create complex input315    let mut complex_input: Vec<Complex<f64>> = input316        .iter()317        .map(|&val| Complex::new(val, 0.0))318        .collect();319320    // Perform the FFT321    fft.process(&mut complex_input);322323    complex_input324}325326use statrs::statistics::Statistics;327328fn non_chaoticness(m1: f64, m2: f64, m3: f64, positions: &Vec<Vec<Vector3<f64>>>) -> f64 {329    let mut r1: Vec<f64> = vec![0.0; positions[0].len()];330    let mut r2: Vec<f64> = vec![0.0; positions[0].len()];331    let mut r3: Vec<f64> = vec![0.0; positions[0].len()];332333    for i in 0..positions[0].len() {334        let p1 = positions[0][i];335        let p2 = positions[1][i];336        let p3 = positions[2][i];337338        let center_of_mass1 = (m2 * p2 + m3 * p3) / (m2 + m3);339        let center_of_mass2 = (m1 * p1 + m3 * p3) / (m1 + m3);340        let center_of_mass3 = (m2 * p2 + m1 * p1) / (m2 + m1);341342        let dist1 = p1 - center_of_mass1;343        let dist2 = p2 - center_of_mass2;344        let dist3 = p3 - center_of_mass3;345346        r1[i] = dist1.norm();347        r2[i] = dist2.norm();348        r3[i] = dist3.norm();349    }350351    let result1 = fourier_transform(&r1);352    let result2 = fourier_transform(&r2);353    let result3 = fourier_transform(&r3);354355    let absolute1: Vec<f64> = result1356        .iter()357        .map(|&val| (val.norm()))358        .collect();359360    let absolute2: Vec<f64> = result2361        .iter()362        .map(|&val| (val.norm()))363        .collect();364365    let absolute3: Vec<f64> = result3366        .iter()367        .map(|&val| (val.norm()))368        .collect();369370    let final_result1 = absolute1.std_dev().sqrt();371    let final_result2 = absolute2.std_dev().sqrt();372    let final_result3 = absolute3.std_dev().sqrt();373374    (final_result1 + final_result2 + final_result3) / 3.0375}376377use std::io::Write;378use std::process::{Command, Stdio};379use image::DynamicImage;380381fn create_video_from_frames_in_memory(frames: &[ImageBuffer<Rgb<u8>, Vec<u8>>], output_file: &str, frame_rate: u32) {382    let mut command = Command::new("ffmpeg");383    command384        .arg("-y") // Overwrite the output file if it exists385        .arg("-f")386        .arg("image2pipe")387        .arg("-vcodec")388        .arg("png")389        .arg("-r")390        .arg(frame_rate.to_string())391        .arg("-i")392        .arg("-")393        .arg("-c:v")394        .arg("libx264")395        .arg("-pix_fmt")396        .arg("yuv420p")397        .arg(output_file)398        .stdin(Stdio::piped())399        .stdout(Stdio::piped())400        .stderr(Stdio::piped());401402    let mut ffmpeg = command.spawn().expect("Failed to spawn ffmpeg process");403    let ffmpeg_stdin = ffmpeg.stdin.as_mut().expect("Failed to open ffmpeg stdin");404405    for frame in frames {406        let dyn_image = DynamicImage::ImageRgb8(frame.clone());407        dyn_image408            .write_to(ffmpeg_stdin, image::ImageOutputFormat::Png)409            .expect("Failed to write frame to ffmpeg stdin");410    }411412    ffmpeg_stdin.flush().expect("Failed to flush ffmpeg stdin");413    drop(ffmpeg_stdin); // Close stdin to signal EOF to ffmpeg414415    let output = ffmpeg.wait_with_output().expect("Failed to wait on ffmpeg process");416417    if !output.status.success() {418        eprintln!(419            "ffmpeg exited with an error: {}",420            String::from_utf8_lossy(&output.stderr)421        );422    }423}424425fn get_positions(mut bodies: Vec<Body>, num_steps: usize) -> Vec<Vec<Vector3<f64>>> {426    let dt = 0.001;427428    let mut positions = vec![vec![Vector3::zeros(); num_steps]; bodies.len()];429430    for step in 0..num_steps {431        for (i, body) in bodies.iter().enumerate() {432            positions[i][step] = body.position;433        }434        verlet_step(&mut bodies, dt);435    }436    positions437}438439fn get_best(rng: &mut Sha3RandomByteStream, num_iters: usize, num_steps_sim: usize, num_steps_video: usize) -> Vec<Vec<Vector3<f64>>> {440441    let mut many_bodies: Vec<Vec<Body>> = vec![];442    for _ in 0..num_iters {443        let body1 = Body::new(rng.random_mass(), Vector3::new(rng.random_location(), rng.random_location(), 0.0), Vector3::new(0.0, 0.0, rng.random_velocity()));444        let body2 = Body::new(rng.random_mass(), Vector3::new(rng.random_location(), rng.random_location(), 0.0), Vector3::new(0.0, 0.0, rng.random_velocity()));445        let body3 = Body::new(rng.random_mass(), Vector3::new(rng.random_location(), rng.random_location(), 0.0), Vector3::new(0.0, 0.0, rng.random_velocity()));446447        let bodies = vec![body1, body2, body3];448        many_bodies.push(bodies);449    }450451    let mut results_par = vec![0.0; many_bodies.len()];452    many_bodies.par_iter().map(|bodies| {453        let m1 = bodies[0].mass;454        let m2 = bodies[1].mass;455        let m3 = bodies[2].mass;456        let positions = get_positions(bodies.clone() , num_steps_sim);457        non_chaoticness(m1, m2, m3, &positions)458    }).collect_into_vec(&mut results_par);459460    let mut best_idx = 0;461    let mut best_result = f64::INFINITY;462    for (i, &res) in results_par.iter().enumerate() {463        if res < best_result {464            best_result = res;465            best_idx = i;466        }467    }468469    let bodies = &many_bodies[best_idx];470    println!("mass: {} {} {} pos: {} {} | {} {} | {} {}",471        bodies[0].mass, bodies[1].mass, bodies[2].mass,472        bodies[0].position[0], bodies[0].position[1],473        bodies[1].position[0], bodies[1].position[1],474        bodies[2].position[0], bodies[2].position[1]);475    get_positions(bodies.clone(), num_steps_video)476}477478use clap::Parser;479480/// Simple program to greet a person481#[derive(Parser, Debug)]482#[command(author, version, about, long_about = None)]483struct Args {484    #[arg(long, default_value = "00")]485    seed: String,486487    #[arg(long, default_value = "output")]488    file_name: String,489}490491use hex;492493fn main() {494    let args = Args::parse();495    let string_seed = if args.seed.starts_with("0x") {496            args.seed[2..].to_string()497        } else {498            args.seed.to_string()499        };500    let seed = hex::decode(string_seed).expect("Invalid hexadecimal string");501502    let mut byte_stream = Sha3RandomByteStream::new(&seed);503504505    let steps = byte_stream.gen_range(400_000.0, 500_000.0) as usize;506    const NUM_TRIES: usize = 1_000;507    let positions = get_best(&mut byte_stream, NUM_TRIES, steps, steps);508    let colors = get_3_colors(&mut byte_stream, steps);509    let s: &str = args.file_name.as_str();510    let file_name = format!("{}.mp4", s);511    println!("done simulating");512513    let snake_len = byte_stream.gen_range(0.2, 2.0);514    let init_len: usize = 0;515    let hide_2 = true;516    let hide_3 = true;517    let hide = vec![false, hide_2, hide_3];518519    const NUM_SECONDS: usize = 15;520    let target_length = 60 * NUM_SECONDS;521    let steps_per_frame: usize = steps / target_length;522    const FRAME_SIZE: u32 = 800;523524    let frames = plot_positions(&positions, FRAME_SIZE, snake_len, init_len, &hide, &colors, steps_per_frame);525    let last_frame = frames[frames.len() - 1].clone();526    if let Err(e) = last_frame.save(format!("{}.png", s)) {527        eprintln!("Error saving image: {:?}", e);528    } else {529        println!("Image saved successfully.");530    }531    create_video_from_frames_in_memory(&frames, &file_name, 60);532    println!("done creating video");533}534