cosmol-viewer 0.1.2.dev5__tar.gz → 0.1.3.dev1__tar.gz

{cosmol_viewer-0.1.2.dev5 → cosmol_viewer-0.1.3.dev1}/Cargo.lock

@@ -727,7 +727,7 @@ dependencies = [
 
 [[package]]
 name = "cosmol_viewer"
-version = "0.1.2-nightly.5"
+version = "0.1.3-nightly.1"
 dependencies = [
  "bytemuck",
  "cosmol_viewer_core",
@@ -740,7 +740,7 @@ dependencies = [
 
 [[package]]
 name = "cosmol_viewer_core"
-version = "0.1.2-nightly.5"
+version = "0.1.3-nightly.1"
 dependencies = [
  "bytemuck",
  "eframe",
@@ -770,11 +770,12 @@ dependencies = [
 
 [[package]]
 name = "cosmol_viewer_wasm"
-version = "0.1.2-nightly.5"
+version = "0.1.3-nightly.1"
 dependencies = [
  "base64",
  "cosmol_viewer_core",
  "eframe",
+ "gloo-timers",
  "log",
  "pyo3",
  "serde",
@@ -1255,6 +1256,15 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "futures-channel"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
+dependencies = [
+ "futures-core",
+]
+
 [[package]]
 name = "futures-core"
 version = "0.3.31"
@@ -1374,6 +1384,18 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "gloo-timers"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbb143cf96099802033e0d4f4963b19fd2e0b728bcf076cd9cf7f6634f092994"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "js-sys",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "glow"
 version = "0.16.0"

{cosmol_viewer-0.1.2.dev5 → cosmol_viewer-0.1.3.dev1}/Cargo.toml

@@ -1,6 +1,6 @@
 [workspace.package]
 edition = "2024"
-version = "0.1.2-nightly.5"
+version = "0.1.3-nightly.1"
 authors = ["9028 wjt@cosmol.org"]
 repository = "https://github.com/COSMol-repl/COSMol-viewer"
 homepage = "https://github.com/COSMol-repl/COSMol-viewer"
@@ -13,8 +13,8 @@ resolver = "2"
 members = ["crates/python"]
 
 [workspace.dependencies]
-cosmol_viewer = { version = "0.1.2-nightly.5", path = "cosmol_viewer"}
-cosmol_viewer_core = { version = "0.1.2-nightly.5", path = "crates/core" }
+cosmol_viewer = { version = "0.1.3-nightly.1", path = "cosmol_viewer"}
+cosmol_viewer_core = { version = "0.1.3-nightly.1", path = "crates/core" }
 
 eframe = { version = "0.32.0", features = ["wayland","x11"] }
 pyo3 = { version = "0.25.1", features = ["extension-module", "abi3-py37"] }

cosmol_viewer-0.1.3.dev1/PKG-INFO

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: cosmol-viewer
+Version: 0.1.3.dev1
+Summary: Molecular visualization tools
+Author-email: 95028 <wjt@cosmol.org>
+Project-URL: Repository, https://github.com/COSMol-repl/COSMol-viewer

{cosmol_viewer-0.1.2.dev5 → cosmol_viewer-0.1.3.dev1}/crates/core/src/lib.rs

@@ -38,6 +38,23 @@ pub struct App {
 }
 
 impl App {
+    pub fn play(
+        cc: &eframe::CreationContext<'_>,
+        frames: Vec<Scene>,
+        interval: f32,
+        loop_: bool,
+    ) -> Self {
+        let gl = cc.gl.clone();
+        let canvas = Canvas::new(gl.as_ref().unwrap().clone(), frames[0].clone()).unwrap();
+        App {
+            gl,
+            canvas,
+            ctx: cc.egui_ctx.clone(),
+            screenshot_requested: false,
+            screenshot_result: None,
+        }
+    }
+
     pub fn new(cc: &eframe::CreationContext<'_>, scene: Scene) -> Self {
         let gl = cc.gl.clone();
         let canvas = Canvas::new(gl.as_ref().unwrap().clone(), scene).unwrap();
@@ -130,7 +147,7 @@ pub struct NativeGuiViewer {
 }
 
 impl NativeGuiViewer {
-    pub fn render(scene: &Scene) -> Self {
+    pub fn render(scene: &Scene, width: f32, height: f32) -> Self {
         use std::{
             sync::{Arc, Mutex},
             thread,
@@ -142,7 +159,7 @@ impl NativeGuiViewer {
             egui::{Vec2, ViewportBuilder},
         };
 
-        let viewport_size = scene.viewport.unwrap_or([800, 500]);
+        // let viewport_size = scene.viewport.unwrap_or([800, 500]);
 
         let app: Arc<Mutex<Option<App>>> = Arc::new(Mutex::new(None));
         let app_clone = Arc::clone(&app);
@@ -173,8 +190,7 @@ impl NativeGuiViewer {
                 }));
 
             let native_options = NativeOptions {
-                viewport: ViewportBuilder::default()
-                    .with_inner_size(Vec2::new(viewport_size[0] as f32, viewport_size[1] as f32)),
+                viewport: ViewportBuilder::default().with_inner_size(Vec2::new(width, height)),
                 depth_buffer: 24,
                 event_loop_builder,
                 ..Default::default()
@@ -193,7 +209,7 @@ impl NativeGuiViewer {
         });
 
         // 等待 App 初始化完成
-        let timeout_ms = 3000;
+        let timeout_ms = 30000;
         let mut waited = 0;
 
         loop {
@@ -244,4 +260,100 @@ impl NativeGuiViewer {
             std::thread::sleep(std::time::Duration::from_millis(100));
         }
     }
+
+    pub fn play(frames: Vec<Scene>, interval: f32, loops: i64, width: f32, height: f32) {
+        use std::{
+            sync::{Arc, Mutex},
+            thread,
+        };
+
+        #[cfg(not(target_arch = "wasm32"))]
+        use eframe::{
+            NativeOptions,
+            egui::{Vec2, ViewportBuilder},
+        };
+
+        let app: Arc<Mutex<Option<App>>> = Arc::new(Mutex::new(None));
+        let app_clone = Arc::clone(&app);
+
+        let scene_init = frames[0].clone();
+
+        #[cfg(not(target_arch = "wasm32"))]
+        thread::spawn(move || {
+            use std::process;
+
+            use eframe::{EventLoopBuilderHook, run_native};
+            let event_loop_builder: Option<EventLoopBuilderHook> =
+                Some(Box::new(|event_loop_builder| {
+                    #[cfg(target_family = "windows")]
+                    {
+                        use egui_winit::winit::platform::windows::EventLoopBuilderExtWindows;
+                        event_loop_builder.with_any_thread(true);
+                    }
+                    #[cfg(feature = "wayland")]
+                    {
+                        use egui_winit::winit::platform::wayland::EventLoopBuilderExtWayland;
+                        event_loop_builder.with_any_thread(true);
+                    }
+                    #[cfg(feature = "x11")]
+                    {
+                        use egui_winit::winit::platform::x11::EventLoopBuilderExtX11;
+                        event_loop_builder.with_any_thread(true);
+                    }
+                }));
+
+            let native_options = NativeOptions {
+                viewport: ViewportBuilder::default().with_inner_size(Vec2::new(width, height)),
+                depth_buffer: 24,
+                event_loop_builder,
+                ..Default::default()
+            };
+
+            let _ = run_native(
+                "cosmol_viewer",
+                native_options,
+                Box::new(move |cc| {
+                    let mut guard = app_clone.lock().unwrap();
+                    *guard = Some(App::new(cc, scene_init));
+                    Ok(Box::new(AppWrapper(app_clone.clone())))
+                }),
+            );
+            process::exit(0);
+        });
+
+        // 等待 App 初始化完成
+        let timeout_ms = 30000;
+        let mut waited = 0;
+
+        loop {
+            if app.lock().unwrap().is_some() {
+                break;
+            }
+            if waited > timeout_ms {
+                panic!("Fail to initialize App");
+            }
+            thread::sleep(Duration::from_millis(10));
+            waited += 10;
+        }
+
+        let mut count = 0;
+        loop {
+            if loops >= 0 && count >= loops {
+                break;
+            }
+            count += 1;
+            for frame in &frames {
+                {
+                    let mut guard = app.lock().unwrap();
+                    if let Some(app) = &mut *guard {
+                        app.update_scene(frame.clone());
+                        app.ctx.request_repaint();
+                    }
+                }
+                thread::sleep(Duration::from_secs_f32(interval));
+            }
+        }
+
+        // Self { app }
+    }
 }

{cosmol_viewer-0.1.2.dev5 → cosmol_viewer-0.1.3.dev1}/crates/core/src/scene.rs

@@ -66,9 +66,9 @@ impl Scene {
         }
     }
 
-    pub fn set_viewport(&mut self, width: usize, height: usize) {
-        self.viewport = Some([width, height]);
-    }
+    // pub fn set_viewport(&mut self, width: usize, height: usize) {
+    //     self.viewport = Some([width, height]);
+    // }
 
     pub fn set_background_color(&mut self, background_color: [f32; 3]) {
         self.background_color = background_color;

{cosmol_viewer-0.1.2.dev5 → cosmol_viewer-0.1.3.dev1}/crates/python/Cargo.toml

@@ -2,6 +2,7 @@
 name = "cosmol_viewer_python"
 edition.workspace = true
 publish = false
+readme = "README.md"
 
 [dependencies]
 cosmol_viewer_core.workspace = true

{cosmol_viewer-0.1.2.dev5 → cosmol_viewer-0.1.3.dev1}/crates/python/README.md

@@ -7,6 +7,9 @@
   <a href="https://pypi.org/project/cosmol_viewer/">
     <img src="https://img.shields.io/pypi/v/cosmol_viewer.svg" alt="PyPi Latest Release"/>
   </a>
+    <a href="https://cosmol-repl.github.io/COSMol-viewer">
+    <img src="https://img.shields.io/badge/docs-latest-blue.svg" alt="Documentation Status"/>
+  </a>
 </div>
 
 A high-performance molecular visualization library built with Rust and WebGPU, designed for seamless integration into Python workflows.

{cosmol_viewer-0.1.2.dev5 → cosmol_viewer-0.1.3.dev1}/crates/python/src/lib.rs

@@ -9,10 +9,12 @@ use crate::{
 };
 use cosmol_viewer_core::{NativeGuiViewer, scene::Scene as _Scene};
 use cosmol_viewer_wasm::{WasmViewer, setup_wasm_if_needed};
+use std::borrow::Borrow;
 
 mod parser;
 mod shapes;
 
+#[derive(Clone)]
 #[pyclass]
 /// A 3D scene container for visualizing molecular or geometric shapes.
 ///
@@ -107,20 +109,6 @@ impl Scene {
         self.inner.delete_shape(id);
     }
 
-    /// Set the viewport size of the scene.
-    ///
-    /// # Arguments
-    ///
-    /// * `width` - Width of the viewport in pixels.
-    /// * `height` - Height of the viewport in pixels.
-    ///
-    /// # Example
-    /// ```python
-    /// scene.set_viewport(600, 400)
-    /// ```
-    pub fn set_viewport(&mut self, width: usize, height: usize) {
-        self.inner.set_viewport(width, height);
-    }
 
     /// Sets the global scale factor of the scene.
     ///
@@ -186,9 +174,9 @@ impl std::fmt::Display for RuntimeEnv {
 ///
 /// Use `Viewer.render(scene)` to create and display a viewer instance.
 ///
-/// Examples:
+/// # Examples:
 /// ```python
-/// from cosmol import Viewer, Scene, Sphere
+/// from cosmol_viewer import Viewer, Scene, Sphere
 /// scene = Scene()
 /// scene.add_shape(Sphere(...))
 /// viewer = Viewer.render(scene)
@@ -265,32 +253,34 @@ impl Viewer {
     ///
     /// Args:
     ///     scene (Scene): The scene to render.
+    ///     width (float): The width of the viewport in pixels.
+    ///     height (float): The height of the viewport in pixels.
     ///
     /// Returns:
     ///     Viewer: The created viewer instance.
     ///
     /// Examples:
     /// ```python
-    /// from cosmol cosmol_viewer Viewer, Scene, Sphere
+    /// from cosmol_viewer import Viewer, Scene, Sphere
     ///
     /// scene = Scene()
     /// scene.add_shape(Sphere(center=[0.0, 0.0, 0.0], radius=1.0))
     ///
-    /// viewer = Viewer.render(scene)
+    /// viewer = Viewer.render(scene, 800.0, 500.0)
     /// ```
-    pub fn render(scene: &Scene, py: Python) -> Self {
+    pub fn render(scene: &Scene, width: f32, height: f32, py: Python) -> Self {
         let env_type = detect_runtime_env(py).unwrap();
         match env_type {
             RuntimeEnv::Colab | RuntimeEnv::Jupyter => {
                 print_to_notebook(
                     c_str!(
                         r#"from IPython.display import display, HTML
-display(HTML("<div style='color:red;font-weight:bold;'>⚠️ Note: When running in Jupyter or Colab, animation updates may be limited by the notebook's output capacity, which can cause incomplete or delayed rendering.</div>"))"#
+display(HTML("<div style='color:red;font-weight:bold;font-size:1rem;'>⚠️ Note: When running in Jupyter or Colab, animation updates may be limited by the notebook's output capacity, which can cause incomplete or delayed rendering.</div>"))"#
                     ),
                     py,
                 );
                 setup_wasm_if_needed(py);
-                let wasm_viewer = WasmViewer::initate_viewer(py, &scene.inner);
+                let wasm_viewer = WasmViewer::initate_viewer(py, &scene.inner, width, height);
 
                 Viewer {
                     environment: env_type,
@@ -301,12 +291,71 @@ display(HTML("<div style='color:red;font-weight:bold;'>⚠️ Note: When running
             RuntimeEnv::PlainScript | RuntimeEnv::IPythonTerminal => Viewer {
                 environment: env_type,
                 wasm_viewer: None,
-                native_gui_viewer: Some(NativeGuiViewer::render(&scene.inner)),
+                native_gui_viewer: Some(NativeGuiViewer::render(&scene.inner, width, height)),
             },
             _ => panic!("Error: Invalid runtime environment"),
         }
     }
 
+    #[staticmethod]
+    /// Render a 3D scene based on the current environment.
+    ///
+    /// If running inside Jupyter or Colab, the scene will be displayed inline using WebAssembly.
+    /// If running from a script or terminal, a native GUI window is used (if supported).
+    ///
+    /// Args:
+    ///     scene (Scene): The scene to render.
+    ///     width (float): The width of the viewport in pixels.
+    ///     height (float): The height of the viewport in pixels.
+    ///
+    /// Returns:
+    ///     Viewer: The created viewer instance.
+    ///
+    /// Examples:
+    /// ```python
+    /// from cosmol_viewer import Viewer, Scene, Sphere
+    ///
+    /// scene = Scene()
+    /// scene.add_shape(Sphere(center=[0.0, 0.0, 0.0], radius=1.0))
+    ///
+    /// viewer = Viewer.render(scene, 800.0, 500.0)
+    /// ```
+    pub fn play(
+        frames: Vec<Scene>,
+        interval: f32,
+        loops: i64,
+        width: f32,
+        height: f32,
+        py: Python,
+    ) -> Self {
+        let env_type = detect_runtime_env(py).unwrap();
+        let rust_frames: Vec<_Scene> = frames.iter().map(|frame| frame.inner.clone()).collect();
+
+        match env_type {
+            RuntimeEnv::Colab | RuntimeEnv::Jupyter => {
+                setup_wasm_if_needed(py);
+                let wasm_viewer = WasmViewer::initate_viewer_and_play(py, rust_frames, (interval * 1000.0) as u64, loops, width, height);
+
+                Viewer {
+                    environment: env_type,
+                    wasm_viewer: Some(wasm_viewer),
+                    native_gui_viewer: None,
+                }
+            }
+
+            RuntimeEnv::PlainScript | RuntimeEnv::IPythonTerminal => {
+                NativeGuiViewer::play(rust_frames, interval, loops, width, height);
+
+                Viewer {
+                    environment: env_type,
+                    wasm_viewer: None,
+                    native_gui_viewer: None,
+                }
+            }
+            _ => panic!("Error: Invalid runtime environment"),
+        }
+    }
+
     /// Update the viewer with a new scene.
     ///
     /// Works for both Web-based rendering (Jupyter/Colab) and native GUI windows.
@@ -362,11 +411,13 @@ display(HTML("<div style='color:red;font-weight:bold;'>⚠️ Note: When running
                 // let image = self.wasm_viewer.as_ref().unwrap().take_screenshot(py);
                 print_to_notebook(
                     c_str!(
-                        r#"<div style='color:red;font-weight:bold;'>⚠️ Image saving in Jupyter/Colab is not yet fully supported. This feature is still under development.</div>"))"#
+                        r#"<div style='color:red;font-weight:bold;font-size:1rem;'>⚠️ Image saving in Jupyter/Colab is not yet fully supported.</div>"))"#
                     ),
                     py,
                 );
-                panic!("Error saving image. Saving images from Jupyter/Colab is not yet supported. This feature is still under development.")
+                panic!(
+                    "Error saving image. Saving images from Jupyter/Colab is not yet supported."
+                )
             }
             RuntimeEnv::PlainScript | RuntimeEnv::IPythonTerminal => {
                 let native_gui_viewer = &self.native_gui_viewer.as_ref().unwrap();
@@ -394,3 +445,9 @@ fn cosmol_viewer(_py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(parse_sdf, m)?)?;
     Ok(())
 }
+
+fn a(py: Python, frame: Py<Scene>) -> usize {
+    let sc: Scene = frame.extract(py).unwrap();
+
+    1
+}

{cosmol_viewer-0.1.2.dev5 → cosmol_viewer-0.1.3.dev1}/crates/python/src/shapes.rs

@@ -101,7 +101,7 @@ impl PySphere {
 ///
 /// # Examples
 /// ```python
-/// from cosmol import Scene, Stick, Viewer
+/// from cosmol_viewer import Scene, Stick, Viewer
 ///
 /// stick = Stick([0.0, 0.0, 0.0], [1.0, 1.0, 1.0], 0.05)
 /// stick = stick.color([0.5, 0.8, 1.0]).opacity(0.7)
@@ -132,7 +132,7 @@ impl PyStick {
     /// # Returns
     /// `Stick`: The updated stick object.
     ///
-    /// # Example
+    /// # Examples
     /// ```python
     /// stick.color([1.0, 0.0, 0.0])
     /// ```

{cosmol_viewer-0.1.2.dev5 → cosmol_viewer-0.1.3.dev1}/crates/wasm/Cargo.toml

@@ -15,7 +15,7 @@ eframe = { workspace = true, optional = true }
 wasm-bindgen-futures = { version = "0.4.50", optional = true }
 web-sys = { version = "0.3.77", features = ["HtmlCanvasElement"], optional = true }
 wasm-bindgen = { version = "0.2.100", optional = true }
-
+gloo-timers = { version = "0.3.0", features = ["futures-core", "futures"], optional = true }
 pyo3 = { workspace = true, optional = true }
 base64 = { version = "0.22.1", optional = true }
 
@@ -26,7 +26,8 @@ wasm = [
     "eframe",
     "wasm-bindgen-futures",
     "web-sys",
-    "wasm-bindgen"
+    "wasm-bindgen",
+    "gloo-timers"
 ]
 
 js_bridge = [

cosmol_viewer-0.1.3.dev1/crates/wasm/src/lib.rs

@@ -0,0 +1,420 @@
+use cosmol_viewer_core::App;
+use cosmol_viewer_core::scene::Scene;
+#[cfg(feature = "js_bridge")]
+use serde::Serialize;
+use std::sync::Arc;
+use std::sync::Mutex;
+
+const VERSION: &str = env!("CARGO_PKG_VERSION"); // crate 当前版本号
+
+#[cfg(feature = "wasm")]
+use web_sys::HtmlCanvasElement;
+
+#[cfg(feature = "wasm")]
+use wasm_bindgen::JsValue;
+#[cfg(feature = "wasm")]
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[cfg(feature = "js_bridge")]
+use pyo3::Python;
+#[cfg(feature = "js_bridge")]
+pub fn setup_wasm_if_needed(py: Python) {
+    use base64::Engine;
+    use pyo3::types::PyAnyMethods;
+
+    const JS_CODE: &str = include_str!("../../wasm/pkg/cosmol_viewer_wasm.js");
+    const WASM_BYTES: &[u8] = include_bytes!("../../wasm/pkg/cosmol_viewer_wasm_bg.wasm");
+
+    let js_base64 = base64::engine::general_purpose::STANDARD.encode(JS_CODE);
+    let wasm_base64 = base64::engine::general_purpose::STANDARD.encode(WASM_BYTES);
+
+    let combined_js = format!(
+        r#"
+(function() {{
+    const version = "{VERSION}";
+    const ns = "cosmol_viewer_" + version;
+
+    if (!window[ns + "_ready"]) {{
+        // 1. setup JS module
+        const jsCode = atob("{js_base64}");
+        const jsBlob = new Blob([jsCode], {{ type: 'application/javascript' }});
+        window[ns + "_blob_url"] = URL.createObjectURL(jsBlob);
+
+        // 2. preload WASM
+        const wasmBytes = Uint8Array.from(atob("{wasm_base64}"), c => c.charCodeAt(0));
+        window[ns + "_wasm_bytes"] = wasmBytes;
+
+        window[ns + "_ready"] = true;
+        console.log("Cosmol viewer setup done, version:", version);
+    }}
+}})();
+        "#,
+        VERSION = VERSION,
+        js_base64 = js_base64,
+        wasm_base64 = wasm_base64
+    );
+
+    let ipython = py.import("IPython.display").unwrap();
+    let display = ipython.getattr("display").unwrap();
+
+    let js = ipython
+        .getattr("Javascript")
+        .unwrap()
+        .call1((combined_js,))
+        .unwrap();
+    display.call1((js,)).unwrap();
+}
+
+#[cfg(feature = "js_bridge")]
+pub struct WasmViewer {
+    pub id: String,
+}
+#[cfg(feature = "js_bridge")]
+impl WasmViewer {
+    pub fn initate_viewer(py: Python, scene: &Scene, width: f32, height: f32) -> Self {
+        use pyo3::types::PyAnyMethods;
+        use uuid::Uuid;
+
+        let unique_id = format!("cosmol_viewer_{}", Uuid::new_v4());
+
+        let html_code = format!(
+            r#"
+<canvas id="{id}" width="{width}" height="{height}" style="width:{width}px; height:{height}px;"></canvas>
+            "#,
+            id = unique_id,
+            width = width,
+            height = height
+        );
+
+        let scene_json = serde_json::to_string(scene).unwrap();
+        let escaped = serde_json::to_string(&scene_json).unwrap();
+
+        let combined_js = format!(
+            r#"
+(function() {{
+    const version = "{VERSION}";
+    const ns = "cosmol_viewer_" + version;
+
+    import(window[ns + "_blob_url"]).then(async (mod) => {{
+        await mod.default(window[ns + "_wasm_bytes"]);
+
+        const canvas = document.getElementById('{id}');
+        const app = new mod.WebHandle();
+        const sceneJson = {SCENE_JSON};
+        await app.start_with_scene(canvas, sceneJson);
+
+        window[ns + "_instances"] = window[ns + "_instances"] || {{}};
+        window[ns + "_instances"]["{id}"] = app;
+        console.log("Cosmol viewer instance {id} (v{VERSION}) started");
+    }});
+}})();
+    "#,
+            VERSION = VERSION,
+            id = unique_id,
+            SCENE_JSON = escaped
+        );
+        let ipython = py.import("IPython.display").unwrap();
+        let display = ipython.getattr("display").unwrap();
+
+        let html = ipython
+            .getattr("HTML")
+            .unwrap()
+            .call1((html_code,))
+            .unwrap();
+        display.call1((html,)).unwrap();
+
+        let js = ipython
+            .getattr("Javascript")
+            .unwrap()
+            .call1((combined_js,))
+            .unwrap();
+        display.call1((js,)).unwrap();
+
+        Self { id: unique_id }
+    }
+
+    pub fn initate_viewer_and_play(
+        py: Python,
+        frames: Vec<Scene>,
+        interval: u64,
+        loops: i64,
+        width: f32,
+        height: f32,
+    ) -> Self {
+        use pyo3::types::PyAnyMethods;
+        use uuid::Uuid;
+
+        let unique_id = format!("cosmol_viewer_{}", Uuid::new_v4());
+
+        let html_code = format!(
+            r#"
+<canvas id="{id}" width="{width}" height="{height}" style="width:{width}px; height:{height}px;"></canvas>
+            "#,
+            id = unique_id,
+            width = width,
+            height = height
+        );
+
+        let frames_json = serde_json::to_string(&Frames {
+            frames,
+            interval,
+            loops,
+        })
+        .unwrap();
+        let escaped = serde_json::to_string(&frames_json).unwrap();
+
+        let combined_js = format!(
+            r#"
+(function() {{
+    const version = "{VERSION}";
+    const ns = "cosmol_viewer_" + version;
+
+    import(window[ns + "_blob_url"]).then(async (mod) => {{
+        await mod.default(window[ns + "_wasm_bytes"]);
+
+        const canvas = document.getElementById('{id}');
+        const app = new mod.WebHandle();
+        const framesJson = {FRAMES_JSON};
+        await app.initate_viewer_and_play(canvas, framesJson);
+
+        window[ns + "_instances"] = window[ns + "_instances"] || {{}};
+        window[ns + "_instances"]["{id}"] = app;
+        console.log("Cosmol viewer instance {id} (v{VERSION}) started");
+    }});
+}})();
+    "#,
+            VERSION = VERSION,
+            id = unique_id,
+            FRAMES_JSON = escaped
+        );
+        let ipython = py.import("IPython.display").unwrap();
+        let display = ipython.getattr("display").unwrap();
+
+        let html = ipython
+            .getattr("HTML")
+            .unwrap()
+            .call1((html_code,))
+            .unwrap();
+        display.call1((html,)).unwrap();
+
+        let js = ipython
+            .getattr("Javascript")
+            .unwrap()
+            .call1((combined_js,))
+            .unwrap();
+        display.call1((js,)).unwrap();
+
+        Self { id: unique_id }
+    }
+
+    pub fn call<T: Serialize>(&self, py: Python, name: &str, input: T) -> () {
+        use pyo3::types::PyAnyMethods;
+
+        let input_json = serde_json::to_string(&input).unwrap();
+        let escaped = serde_json::to_string(&input_json).unwrap();
+        let combined_js = format!(
+            r#"
+(async function() {{
+    const ns = "cosmol_viewer_" + "{VERSION}";
+    const instances = window[ns + "_instances"] || {{}};
+    const app = instances["{id}"];
+    if (app) {{
+        try {{
+            const result = await app.{name}({escaped});
+            console.log("Call `{name}` on instance {id} (v{VERSION}) result:", result);
+        }} catch (err) {{
+            console.error("Error calling `{name}` on instance {id} (v{VERSION}):", err);
+        }}
+    }} else {{
+        console.error("No app found for ID {id} in namespace", ns);
+    }}
+}})();
+        "#,
+            VERSION = VERSION,
+            id = self.id,
+            name = name,
+            escaped = escaped
+        );
+
+        let ipython = py.import("IPython.display").unwrap();
+        let display = ipython.getattr("display").unwrap();
+
+        let js = ipython
+            .getattr("Javascript")
+            .unwrap()
+            .call1((combined_js,))
+            .unwrap();
+        let _ = display.call1((js,));
+    }
+
+    pub fn update(&self, py: Python, scene: &Scene) {
+        self.call(py, "update_scene", scene);
+    }
+
+    pub fn take_screenshot(&self, py: Python) {
+        self.call(py, "take_screenshot", None::<u8>)
+    }
+}
+
+#[derive(serde::Serialize, serde::Deserialize)]
+struct Frames {
+    frames: Vec<Scene>,
+    interval: u64,
+    loops: i64, // -1 = infinite
+}
+
+pub trait JsBridge {
+    fn update(scene: &Scene) -> ();
+}
+
+#[cfg(feature = "wasm")]
+#[cfg(target_arch = "wasm32")]
+use eframe::WebRunner;
+
+#[cfg(feature = "wasm")]
+#[cfg(not(target_arch = "wasm32"))]
+struct WebRunner;
+
+#[cfg(feature = "wasm")]
+#[cfg(not(target_arch = "wasm32"))]
+impl WebRunner {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+#[cfg(feature = "wasm")]
+#[wasm_bindgen]
+pub struct WebHandle {
+    runner: WebRunner,
+    app: Arc<Mutex<Option<App>>>,
+}
+
+#[cfg(feature = "wasm")]
+#[wasm_bindgen]
+impl WebHandle {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Self {
+        #[cfg(target_arch = "wasm32")]
+        eframe::WebLogger::init(log::LevelFilter::Debug).ok();
+        Self {
+            runner: WebRunner::new(),
+            app: Arc::new(Mutex::new(None)),
+        }
+    }
+
+    #[wasm_bindgen]
+    pub async fn start_with_scene(
+        &mut self,
+        canvas: HtmlCanvasElement,
+        scene_json: String,
+    ) -> Result<(), JsValue> {
+        let scene: Scene = serde_json::from_str(&scene_json)
+            .map_err(|e| JsValue::from_str(&format!("Scene parse error: {}", e)))?;
+
+        let app = Arc::clone(&self.app);
+
+        #[cfg(target_arch = "wasm32")]
+        let _ = self
+            .runner
+            .start(
+                canvas,
+                eframe::WebOptions::default(),
+                Box::new(move |cc| {
+                    use cosmol_viewer_core::AppWrapper;
+
+                    let mut guard = app.lock().unwrap();
+                    *guard = Some(App::new(cc, scene));
+                    Ok(Box::new(AppWrapper(app.clone())))
+                }),
+            )
+            .await;
+        Ok(())
+    }
+
+    #[wasm_bindgen]
+    pub async fn update_scene(&mut self, scene_json: String) -> Result<(), JsValue> {
+        let scene: Scene = serde_json::from_str(&scene_json)
+            .map_err(|e| JsValue::from_str(&format!("Scene parse error: {}", e)))?;
+
+        let mut app_guard = self.app.lock().unwrap();
+        if let Some(app) = &mut *app_guard {
+            println!("Received scene update");
+            app.update_scene(scene);
+            app.ctx.request_repaint();
+        } else {
+            println!("scene update received but app is not initialized");
+        }
+        Ok(())
+    }
+
+    #[wasm_bindgen]
+    pub async fn initate_viewer_and_play(
+        &mut self,
+        canvas: HtmlCanvasElement,
+        frames_json: String,
+    ) -> Result<(), JsValue> {
+        use std::{thread, time::Duration};
+        let frames: Frames = serde_json::from_str(&frames_json)
+            .map_err(|e| JsValue::from_str(&format!("Frames parse error: {}", e)))?;
+
+        let app = Arc::clone(&self.app);
+
+        let scene = frames.frames[0].clone();
+
+        #[cfg(target_arch = "wasm32")]
+        let _ = self
+            .runner
+            .start(
+                canvas,
+                eframe::WebOptions::default(),
+                Box::new(move |cc| {
+                    use cosmol_viewer_core::AppWrapper;
+
+                    let mut guard = app.lock().unwrap();
+                    *guard = Some(App::new(cc, scene));
+                    Ok(Box::new(AppWrapper(app.clone())))
+                }),
+            )
+            .await;
+
+        let timeout_ms = 30000;
+        let mut waited = 0;
+        loop {
+            if self.app.lock().unwrap().is_some() {
+                break;
+            }
+            if waited > timeout_ms {
+                panic!("Fail to initialize App");
+            }
+            gloo_timers::future::sleep(Duration::from_millis(10)).await;
+            // Delay::new(Duration::from_secs(1)).await.unwrap();
+            waited += 10;
+        }
+
+        let mut count = 0;
+        loop {
+            if frames.loops >= 0 && count >= frames.loops {
+                break;
+            }
+            count += 1;
+            for frame in &frames.frames {
+                {
+                    let mut guard = self.app.lock().unwrap();
+                    if let Some(app) = &mut *guard {
+                        app.update_scene(frame.clone());
+                        app.ctx.request_repaint();
+                    }
+                }
+                gloo_timers::future::sleep(Duration::from_millis(frames.interval)).await;
+            }
+        }
+
+        Ok(())
+    }
+
+    #[wasm_bindgen]
+    pub async fn take_screenshot(&self) -> Option<String> {
+        Some("The returned value is omitted!".to_string())
+    }
+}

{cosmol_viewer-0.1.2.dev5 → cosmol_viewer-0.1.3.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cosmol-viewer"
-version = "0.1.2.dev5"
+version = "0.1.3.dev1"
 description = "Molecular visualization tools"
 authors = [{name = "95028", email = "wjt@cosmol.org"}]
 

cosmol_viewer-0.1.2.dev5/PKG-INFO

@@ -1,70 +0,0 @@
-Metadata-Version: 2.4
-Name: cosmol-viewer
-Version: 0.1.2.dev5
-Summary: Molecular visualization tools
-Author-email: 95028 <wjt@cosmol.org>
-Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-Project-URL: Repository, https://github.com/COSMol-repl/COSMol-viewer
-
-# COSMol-viewer
-
-<div align="center">
-  <a href="https://crates.io/crates/cosmol_viewer">
-    <img src="https://img.shields.io/crates/v/cosmol_viewer.svg" alt="crates.io Latest Release"/>
-  </a>
-  <a href="https://pypi.org/project/cosmol_viewer/">
-    <img src="https://img.shields.io/pypi/v/cosmol_viewer.svg" alt="PyPi Latest Release"/>
-  </a>
-</div>
-
-A high-performance molecular visualization library built with Rust and WebGPU, designed for seamless integration into Python workflows.
-
-- ⚡ Fast: Native-speed rendering powered by Rust and GPU acceleration
-
-- 🧬 Flexible: Load molecules from .sdf, .pdb, and dynamically update 3D structures
-
-- 📓 Notebook-friendly: Fully supports Jupyter and Google Colab — ideal for education, research, and live demos
-
-- 🔁 Real-time updates: Update molecular coordinates on-the-fly for simulations or animations
-
-- 🎨 Customizable: Control styles, camera, and rendering settings programmatically
-
-# Installation
-
-```sh
-pip install cosmol-viewer
-```
-
-# Examples
-
-See examples in [Google Colab](https://colab.research.google.com/drive/1Sw72QWjQh_sbbY43jGyBOfF1AQCycmIx?usp=sharing).
-
-# Usage
-
-```python
-from cosmol_viewer import Scene, Viewer, parse_sdf, Molecules
-
-# === Step 1: Load and render a molecule ===
-with open("molecule.sdf", "r") as f:
-    sdf = f.read()
-    mol = Molecules(parse_sdf(sdf)).centered()
-
-scene = Scene()
-scene.scale(0.1)
-scene.add_shape(mol, "mol")
-
-viewer = Viewer.render(scene)  # Launch the viewer
-
-# === Step 2: Update the same molecule dynamically ===
-import time
-
-for i in range(1, 10):  # Simulate multiple frames
-    with open(f"frames/frame_{i}.sdf", "r") as f:
-        sdf = f.read()
-        updated_mol = Molecules(parse_sdf(sdf)).centered()
-
-    scene.update_shape("mol", updated_mol)
-    viewer.update(scene)
-
-    time.sleep(0.033)  # ~30 FPS
-```

cosmol_viewer-0.1.2.dev5/crates/wasm/src/lib.rs

@@ -1,257 +0,0 @@
-use cosmol_viewer_core::App;
-use cosmol_viewer_core::scene::Scene;
-#[cfg(feature = "js_bridge")]
-use serde::Serialize;
-use std::sync::Arc;
-use std::sync::Mutex;
-
-#[cfg(feature = "wasm")]
-use web_sys::HtmlCanvasElement;
-
-#[cfg(feature = "wasm")]
-use wasm_bindgen::prelude::wasm_bindgen;
-#[cfg(feature = "wasm")]
-use wasm_bindgen::JsValue;
-
-#[cfg(feature = "js_bridge")]
-use pyo3::Python;
-#[cfg(feature = "js_bridge")]
-pub fn setup_wasm_if_needed(py: Python) {
-    use base64::Engine;
-    use pyo3::types::PyAnyMethods;
-
-    const JS_CODE: &str = include_str!("../../wasm/pkg/cosmol_viewer_wasm.js");
-
-    let js_base64 = base64::engine::general_purpose::STANDARD.encode(JS_CODE);
-
-    let combined_js = format!(
-        r#"
-(function() {{
-    if (!window.cosmol_viewer_blob_url) {{
-        const jsCode = atob("{js_base64}");
-        const blob = new Blob([jsCode], {{ type: 'application/javascript' }});
-        window.cosmol_viewer_blob_url = URL.createObjectURL(blob);
-    }}
-}})();
-    "#
-    );
-
-    let ipython = py.import("IPython.display").unwrap();
-    let display = ipython.getattr("display").unwrap();
-
-    let js = ipython
-        .getattr("Javascript")
-        .unwrap()
-        .call1((combined_js,))
-        .unwrap();
-    display.call1((js,)).unwrap();
-}
-
-#[cfg(feature = "js_bridge")]
-pub struct WasmViewer {
-    pub id: String,
-}
-#[cfg(feature = "js_bridge")]
-impl WasmViewer {
-    pub fn initate_viewer(py: Python, scene: &Scene) -> Self {
-        use base64::Engine;
-        use pyo3::types::PyAnyMethods;
-        use uuid::Uuid;
-
-        let unique_id = format!("cosmol_viewer_{}", Uuid::new_v4());
-        const WASM_BYTES: &[u8] = include_bytes!("../../wasm/pkg/cosmol_viewer_wasm_bg.wasm");
-        let wasm_base64 = base64::engine::general_purpose::STANDARD.encode(WASM_BYTES);
-
-        let viewport_size = scene.viewport.unwrap_or([800, 500]);
-
-        let html_code = format!(
-            r#"
-<canvas id="{id}" width="{width}" height="{height}" style="width:{width}px; height:{height}px;"></canvas>
-            "#,
-            id = unique_id,
-            width = viewport_size[0],
-            height = viewport_size[1]
-        );
-
-        let scene_json = serde_json::to_string(scene).unwrap();
-        let escaped = serde_json::to_string(&scene_json).unwrap();
-
-        let combined_js = format!(
-            r#"
-(function() {{
-    const wasmBase64 = "{wasm_base64}";
-    import(window.cosmol_viewer_blob_url).then(async (mod) => {{
-        const wasmBytes = Uint8Array.from(atob(wasmBase64), c => c.charCodeAt(0));
-        await mod.default(wasmBytes);
-
-        const canvas = document.getElementById('{id}');
-        const app = new mod.WebHandle();
-        const sceneJson = {SCENE_JSON};
-        console.log("Starting cosmol_viewer with scene:", sceneJson);
-        await app.start_with_scene(canvas, sceneJson);
-
-        window.cosmol_viewer_instances = window.cosmol_viewer_instances || {{}};
-        window.cosmol_viewer_instances["{id}"] = app;
-    }});
-}})();
-            "#,
-            wasm_base64 = wasm_base64,
-            id = unique_id,
-            SCENE_JSON = escaped
-        );
-        let ipython = py.import("IPython.display").unwrap();
-        let display = ipython.getattr("display").unwrap();
-
-        let html = ipython
-            .getattr("HTML")
-            .unwrap()
-            .call1((html_code,))
-            .unwrap();
-        display.call1((html,)).unwrap();
-
-        let js = ipython
-            .getattr("Javascript")
-            .unwrap()
-            .call1((combined_js,))
-            .unwrap();
-        display.call1((js,)).unwrap();
-
-        Self { id: unique_id }
-    }
-
-    pub fn call<T: Serialize>(&self, py: Python, name: &str, input: T) -> () {
-        use pyo3::types::PyAnyMethods;
-
-        let input_json = serde_json::to_string(&input).unwrap();
-        let escaped = serde_json::to_string(&input_json).unwrap();
-        let combined_js = format!(
-            r#"
-(async function() {{
-    console.log(window.cosmol_viewer_instances)
-    const instances = window.cosmol_viewer_instances || {{}};
-    const app = instances["{id}"];
-    if (app) {{
-        const result = await app.{name}({escaped});
-        console.log("Result:", result);
-        console.log("Result:", app);
-        window.cosmol_viewer_result.set("cosmol_result", result);
-        console.log("Result:", app);
-    }} else {{
-        console.error("No app found for ID {id}");
-    }}
-}})();
-            "#,
-            id = self.id,
-        );
-
-        let ipython = py.import("IPython.display").unwrap();
-        let display = ipython.getattr("display").unwrap();
-
-        let js = ipython
-            .getattr("Javascript")
-            .unwrap()
-            .call1((combined_js,))
-            .unwrap();
-        let _ = display.call1((js,));
-    }
-
-    pub fn update(&self, py: Python, scene: &Scene) {
-        self.call(py, "update_scene", scene);
-    }
-
-    pub fn take_screenshot(&self, py: Python) {
-        self.call(py, "take_screenshot", None::<u8>)
-    }
-}
-
-pub trait JsBridge {
-    fn update(scene: &Scene) -> ();
-}
-
-#[cfg(feature = "wasm")]
-#[cfg(target_arch = "wasm32")]
-use eframe::WebRunner;
-
-#[cfg(feature = "wasm")]
-#[cfg(not(target_arch = "wasm32"))]
-struct WebRunner;
-
-#[cfg(feature = "wasm")]
-#[cfg(not(target_arch = "wasm32"))]
-impl WebRunner {
-    pub fn new() -> Self {
-        Self
-    }
-}
-
-#[cfg(feature = "wasm")]
-#[wasm_bindgen]
-pub struct WebHandle {
-    runner: WebRunner,
-    app: Arc<Mutex<Option<App>>>,
-}
-
-#[cfg(feature = "wasm")]
-#[wasm_bindgen]
-impl WebHandle {
-    
-    #[wasm_bindgen(constructor)]
-    pub fn new() -> Self {
-        #[cfg(target_arch = "wasm32")]
-        eframe::WebLogger::init(log::LevelFilter::Debug).ok();
-        Self {
-            runner: WebRunner::new(),
-            app: Arc::new(Mutex::new(None)),
-        }
-    }
-
-    #[wasm_bindgen]
-    pub async fn start_with_scene(
-        &mut self,
-        canvas: HtmlCanvasElement,
-        scene_json: String,
-    ) -> Result<(), JsValue> {
-        let scene: Scene = serde_json::from_str(&scene_json)
-            .map_err(|e| JsValue::from_str(&format!("Scene parse error: {}", e)))?;
-
-        let app = Arc::clone(&self.app);
-
-        #[cfg(target_arch = "wasm32")]
-        let _ = self
-            .runner
-            .start(
-                canvas,
-                eframe::WebOptions::default(),
-                Box::new(move |cc| {
-                    use cosmol_viewer_core::AppWrapper;
-
-                    let mut guard = app.lock().unwrap();
-                    *guard = Some(App::new(cc, scene));
-                    Ok(Box::new(AppWrapper(app.clone())))
-                }),
-            )
-            .await;
-        Ok(())
-    }
-
-    #[wasm_bindgen]
-    pub async fn update_scene(&mut self, scene_json: String) -> Result<(), JsValue> {
-        let scene: Scene = serde_json::from_str(&scene_json)
-            .map_err(|e| JsValue::from_str(&format!("Scene parse error: {}", e)))?;
-
-        let mut app_guard = self.app.lock().unwrap();
-        if let Some(app) = &mut *app_guard {
-            println!("Received scene update");
-            app.update_scene(scene);
-            app.ctx.request_repaint();
-        } else {
-            println!("scene update received but app is not initialized");
-        }
-        Ok(())
-    }
-
-    #[wasm_bindgen]
-    pub async fn take_screenshot(&self) -> Option<String> {
-        Some("javavavavavavav".to_string())
-    }
-}