JSON.parse(plotly_json_str));
+
+ // Make a copy of the plotJson for modal plot
+ const [modalPlotJson, setModalPlotJson] = React.useState(() => JSON.parse(plotly_json_str));
+
+ // Update plot data when new JSON string comes in
+ React.useEffect(() => {
+ setPlotJson(JSON.parse(plotly_json_str));
+ setModalPlotJson(JSON.parse(plotly_json_str));
+ }, [plotly_json_str]);
+
// Create a modal with the plot, and a button to open it.
const [opened, { open, close }] = useDisclosure(false);
- return (
+ const ddd = (
- {/* Draw static plot in the controlpanel, which can be clicked. */}
+ uuid={uuid}
+ />
- {/* Modal contents. keepMounted makes state changes (eg zoom) to the plot
- persistent. */}
+ uuid={`${uuid}-modal`}
+ />
);
+ const t1 = performance.now();
+ console.warn("PlotlyComponent time:", t1 - t0);
+ return ddd;
+}
+
+// Component for handling plot updates
+export function PlotlyExtendTracesComponent({
+ props: { plotly_element_uuids, x_data, y_data, history_length },
+}: GuiPlotlyExtendTracesMessage) {
+ // Use React hooks to update the plotly object when new data arrives
+ React.useEffect(() => {
+ const t0 = performance.now();
+
+ // Batch all plot elements first
+ const t1 = performance.now();
+ const plotElements = plotly_element_uuids.flatMap(uuid => {
+ const main = document.getElementById(uuid);
+ const modal = document.getElementById(`${uuid}-modal`);
+ return [main, modal].filter(Boolean);
+ });
+ const t2 = performance.now();
+ console.warn("DOM query time:", t2 - t1);
+
+ if (plotElements.length === 0) {
+ console.warn("Could not find any plot elements with UUIDs:", plotly_element_uuids);
+ return;
+ }
+
+ try {
+ // @ts-ignore - Plotly.js is dynamically imported
+ const Plotly = (window as any).Plotly;
+ const t3 = performance.now();
+
+ // Pre-compute trace indices once
+ const traceIndices = Array.from({ length: x_data.length }, (_, i) => i);
+
+ // Update each plot with minimal data processing
+ plotElements.forEach((element, index) => {
+ const t4 = performance.now();
+ // Use a more direct update approach
+ Plotly.extendTraces(
+ element,
+ { x: x_data, y: y_data },
+ traceIndices,
+ history_length,
+ { mode: 'lines' } // Optimize for line plots
+ );
+ const t5 = performance.now();
+ console.warn(`Plot ${index} update time:`, t5 - t4);
+ });
+
+ const t6 = performance.now();
+ console.warn("Total Plotly updates time:", t6 - t3);
+ } catch (error) {
+ console.error("Error updating plots:", error);
+ }
+
+ const t7 = performance.now();
+ console.warn("Total execution time:", t7 - t0);
+
+ }, [plotly_element_uuids, x_data, y_data, history_length]);
+
+ // This component doesn't render anything visible
+ return null;
}
diff --git a/src/viser/client/src/components/plotWorker.ts b/src/viser/client/src/components/plotWorker.ts
new file mode 100644
index 000000000..58281c5a3
--- /dev/null
+++ b/src/viser/client/src/components/plotWorker.ts
@@ -0,0 +1,13 @@
+// Worker for processing plot data
+self.onmessage = (e) => {
+ const { x_data, y_data, history_length } = e.data;
+
+ // Process data in worker thread
+ const processedData = {
+ x: x_data,
+ y: y_data
+ };
+
+ // Send processed data back to main thread
+ self.postMessage({ processedData });
+};
diff --git a/src/viser/client/src/csm/CSM.d.ts b/src/viser/client/src/csm/CSM.d.ts
index 2373bffc4..dae166ed7 100644
--- a/src/viser/client/src/csm/CSM.d.ts
+++ b/src/viser/client/src/csm/CSM.d.ts
@@ -32,12 +32,12 @@ export class CSM {
customSplitsCallback?: (cascades: number, near: number, far: number, breaks: number[]) => void;
fade: boolean;
lights: DirectionalLight[];
-
+
constructor(data: CSMParameters);
-
+
update(): void;
updateFrustums(): void;
remove(): void;
dispose(): void;
setupMaterial(material: Material): void;
-}
\ No newline at end of file
+}
diff --git a/src/viser/infra/_async_message_buffer.py b/src/viser/infra/_async_message_buffer.py
index 6d4058858..67ad82142 100644
--- a/src/viser/infra/_async_message_buffer.py
+++ b/src/viser/infra/_async_message_buffer.py
@@ -155,3 +155,68 @@ async def window_generator(
if flush_wait in done and not self.done:
self.flush_event.clear()
flush_wait = self.event_loop.create_task(self.flush_event.wait())
+
+ # async def window_generator(
+ # self, client_id: int
+ # ) -> AsyncGenerator[Sequence[Message], None]:
+ # """Async iterator over messages. Loops infinitely, and waits when no messages
+ # are available."""
+
+ # last_sent_id = -1 # ID of the last message we've sent
+ # flush_wait = self.event_loop.create_task(self.flush_event.wait())
+
+ # while not self.done:
+ # window: List[Message] = []
+
+ # with self.buffer_lock:
+ # # Get all message IDs > last_sent_id, sorted in order
+ # next_ids = sorted(
+ # msg_id for msg_id in self.message_from_id.keys()
+ # if msg_id > last_sent_id
+ # )
+
+ # for msg_id in next_ids:
+ # # Don't send anything while atomic block is active
+ # if self.atomic_counter > 0:
+ # break
+
+ # with self.buffer_lock:
+ # message = (
+ # self.message_from_id.get(msg_id)
+ # if self.persistent_messages
+ # else self.message_from_id.pop(msg_id, None)
+ # )
+
+ # if message is not None and not self.persistent_messages:
+ # # Clean up redundancy tracking if needed
+ # redundancy_key = message.redundancy_key()
+ # self.id_from_redundancy_key.pop(redundancy_key, None)
+
+ # if message is not None and message.excluded_self_client != client_id:
+ # window.append(message)
+ # last_sent_id = msg_id
+
+ # if len(window) >= self.max_window_size:
+ # break
+
+ # if len(window) > 0:
+ # yield window
+ # else:
+ # # Wait for either new message or flush trigger
+ # await self.message_event.wait()
+ # self.message_event.clear()
+
+ # # Optional delay logic (rate limiting)
+ # with self.buffer_lock:
+ # pending_ids = [
+ # msg_id for msg_id in self.message_from_id.keys()
+ # if msg_id > last_sent_id
+ # ]
+ # if not pending_ids:
+ # done, pending = await asyncio.wait(
+ # [flush_wait], timeout=self.window_duration_sec
+ # )
+ # del pending
+ # if flush_wait in done and not self.done:
+ # self.flush_event.clear()
+ # flush_wait = self.event_loop.create_task(self.flush_event.wait())
diff --git a/src/viser/infra/_infra.py b/src/viser/infra/_infra.py
index b2a861ba7..39379e64a 100644
--- a/src/viser/infra/_infra.py
+++ b/src/viser/infra/_infra.py
@@ -68,9 +68,9 @@ def _insert_message(self, message: Message) -> None:
def insert_sleep(self, duration: float) -> None:
"""Insert a sleep into the recorded file. This can be useful for
dynamic 3D data."""
- assert self._handler._record_handle is not None, (
- "serialize() was already called!"
- )
+ assert (
+ self._handler._record_handle is not None
+ ), "serialize() was already called!"
self._time += duration
def serialize(self) -> bytes:
@@ -81,9 +81,9 @@ def serialize(self) -> bytes:
Returns:
The recording as bytes.
"""
- assert self._handler._record_handle is not None, (
- "serialize() was already called!"
- )
+ assert (
+ self._handler._record_handle is not None
+ ), "serialize() was already called!"
packed_bytes = msgspec.msgpack.encode(
{
@@ -135,9 +135,9 @@ def unregister_handler(
callback: Callable[[ClientId, TMessage], None | Coroutine] | None = None,
):
"""Unregister a handler for a particular message type."""
- assert message_cls in self._incoming_handlers, (
- "Tried to unregister a handler that hasn't been registered."
- )
+ assert (
+ message_cls in self._incoming_handlers
+ ), "Tried to unregister a handler that hasn't been registered."
if callback is None:
self._incoming_handlers.pop(message_cls)
else: