+
+
+
+
+
+
+
diff --git a/src/web/app/src/components/AccordionItem.vue b/src/web/app/src/components/AccordionItem.vue
new file mode 100644
index 00000000..7ad961e3
--- /dev/null
+++ b/src/web/app/src/components/AccordionItem.vue
@@ -0,0 +1,89 @@
+
+
+
+
+
+ {{ title }}
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/web/app/src/components/DisplaySettings.vue b/src/web/app/src/components/DisplaySettings.vue
new file mode 100644
index 00000000..c56cf9b7
--- /dev/null
+++ b/src/web/app/src/components/DisplaySettings.vue
@@ -0,0 +1,69 @@
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/web/app/src/components/MainGrid.vue b/src/web/app/src/components/MainGrid.vue
new file mode 100644
index 00000000..7d974a1a
--- /dev/null
+++ b/src/web/app/src/components/MainGrid.vue
@@ -0,0 +1,135 @@
+
+
+ {{ title }}
+
+
+
+
+
+ ![Rendered Layout]()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/web/app/src/components/MaterialsSettings.vue b/src/web/app/src/components/MaterialsSettings.vue
new file mode 100644
index 00000000..ebe6dfa4
--- /dev/null
+++ b/src/web/app/src/components/MaterialsSettings.vue
@@ -0,0 +1,101 @@
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/web/app/src/components/ParametersPanel.vue b/src/web/app/src/components/ParametersPanel.vue
new file mode 100644
index 00000000..2208b32b
--- /dev/null
+++ b/src/web/app/src/components/ParametersPanel.vue
@@ -0,0 +1,176 @@
+
+
+
+ + +
+
+
+
+
+
+ Parameters
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/web/app/src/components/ScenarioSettings.vue b/src/web/app/src/components/ScenarioSettings.vue
new file mode 100644
index 00000000..c523be7a
--- /dev/null
+++ b/src/web/app/src/components/ScenarioSettings.vue
@@ -0,0 +1,198 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/web/app/src/components/SimulationSettings.vue b/src/web/app/src/components/SimulationSettings.vue
new file mode 100644
index 00000000..195c9e5f
--- /dev/null
+++ b/src/web/app/src/components/SimulationSettings.vue
@@ -0,0 +1,100 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/web/app/src/components/TargetSettings.vue b/src/web/app/src/components/TargetSettings.vue
new file mode 100644
index 00000000..bf26dea8
--- /dev/null
+++ b/src/web/app/src/components/TargetSettings.vue
@@ -0,0 +1,90 @@
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/web/app/src/components/TransducersSettings.vue b/src/web/app/src/components/TransducersSettings.vue
new file mode 100644
index 00000000..66a76352
--- /dev/null
+++ b/src/web/app/src/components/TransducersSettings.vue
@@ -0,0 +1,286 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Added transducers
+ -
+
- + {{ transducer.transducerType }} + + + +
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/web/app/src/components/transducers/FocusedTransducer.vue b/src/web/app/src/components/transducers/FocusedTransducer.vue
new file mode 100644
index 00000000..85e34ed5
--- /dev/null
+++ b/src/web/app/src/components/transducers/FocusedTransducer.vue
@@ -0,0 +1,157 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/web/app/src/components/transducers/PhasedArrayTransducer.vue b/src/web/app/src/components/transducers/PhasedArrayTransducer.vue
new file mode 100644
index 00000000..1933ab2a
--- /dev/null
+++ b/src/web/app/src/components/transducers/PhasedArrayTransducer.vue
@@ -0,0 +1,238 @@
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/web/app/src/components/transducers/PlanarTransducer.vue b/src/web/app/src/components/transducers/PlanarTransducer.vue
new file mode 100644
index 00000000..ebc1f1d7
--- /dev/null
+++ b/src/web/app/src/components/transducers/PlanarTransducer.vue
@@ -0,0 +1,149 @@
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/src/web/app/src/components/transducers/PointTransducer.vue b/src/web/app/src/components/transducers/PointTransducer.vue
new file mode 100644
index 00000000..4cc43dc2
--- /dev/null
+++ b/src/web/app/src/components/transducers/PointTransducer.vue
@@ -0,0 +1,103 @@
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/web/app/src/event-bus.js b/src/web/app/src/event-bus.js
new file mode 100644
index 00000000..bf484970
--- /dev/null
+++ b/src/web/app/src/event-bus.js
@@ -0,0 +1,2 @@
+import mitt from 'mitt';
+export const EventBus = mitt();
diff --git a/src/web/app/src/main.js b/src/web/app/src/main.js
new file mode 100644
index 00000000..17719613
--- /dev/null
+++ b/src/web/app/src/main.js
@@ -0,0 +1,51 @@
+import { createApp } from "vue";
+import App from "./App.vue";
+import { library } from "@fortawesome/fontawesome-svg-core";
+import { faChevronUp, faChevronDown } from "@fortawesome/free-solid-svg-icons";
+import { FontAwesomeIcon } from "@fortawesome/vue-fontawesome";
+import "bootstrap/dist/css/bootstrap.css";
+import "bootstrap/dist/js/bootstrap.js";
+import { Tooltip } from "bootstrap";
+import store from "./store/index";
+
+library.add(faChevronDown, faChevronUp);
+
+const app = createApp(App);
+
+// Define a global custom directive called 'tooltip'
+app.directive("tooltip", {
+ // When the bound element is mounted, and whenever it updates, initialize/update the tooltip
+ mounted(el, binding) {
+ // Create a new Tooltip instance for the element
+ const tooltipTrigger = new Tooltip(el, {
+ title: binding.value || el.getAttribute("title"),
+ placement: binding.arg || "top",
+ trigger: "hover focus",
+ container: "body", // Append the tooltip to the body to prevent layout issues
+ });
+ // Store the tooltip instance on the element for future updates
+ el._tooltip = tooltipTrigger;
+ },
+ updated(el, binding) {
+ if (el._tooltip) {
+ // Update the tooltip content and options
+ el._tooltip.setContent({
+ ".tooltip-inner": binding.value || el.getAttribute("title"),
+ });
+ if (binding.arg) {
+ el._tooltip.updateAttachment(binding.arg);
+ }
+ }
+ },
+ beforeUnmount(el) {
+ if (el._tooltip) {
+ // Destroy the tooltip instance when the directive is unbound
+ el._tooltip.dispose();
+ delete el._tooltip;
+ }
+ },
+});
+
+app.use(store);
+app.component("font-awesome-icon", FontAwesomeIcon);
+app.mount("#app");
diff --git a/src/web/app/src/store/index.js b/src/web/app/src/store/index.js
new file mode 100644
index 00000000..cb08bec8
--- /dev/null
+++ b/src/web/app/src/store/index.js
@@ -0,0 +1,373 @@
+import { createStore } from "vuex";
+
+import { EventBus } from "../event-bus";
+import scenarioSettings from "./modules/scenarioSettings";
+import simulationSettings from "./modules/simulationSettings";
+import displaySettings from "./modules/displaySettings";
+import targetSettings from "./modules/targetSettings";
+import transducersSettings from "./modules/transducersSettings";
+import debounce from "lodash/debounce";
+
+const initialState = () => ({
+ hasSimulation: false,
+ isRunningSimulation: false,
+ isProcessing: false,
+ processingMessage: "",
+
+ materials: [],
+ materialProperties: [],
+ transducerTypes: [],
+});
+
+const store = createStore({
+ modules: {
+ scenarioSettings,
+ simulationSettings,
+ displaySettings,
+ targetSettings,
+ transducersSettings,
+ },
+ state() {
+ return {
+ is2d: true,
+ validity: {
+ scenario: false,
+ display: false,
+ target: false,
+ simulation: false,
+ },
+ ...initialState(),
+ };
+ },
+ mutations: {
+ setComponentValidity(state, { component, isValid }) {
+ state.validity = {
+ ...state.validity,
+ [component]: isValid,
+ };
+ },
+ reset(state) {
+ Object.assign(state, initialState());
+ },
+ set2d(state, payload) {
+ state.is2d = payload;
+ },
+ setInitialValues(state, payload) {
+ state.hasSimulation = payload.has_simulation;
+ state.isRunningSimulation = payload.is_running_simulation;
+ state.materials = payload.materials;
+ state.materialProperties = payload.material_properties;
+ state.transducerTypes = payload.transducer_types;
+
+ this.dispatch("scenarioSettings/setAvailableCTs", payload.available_cts, {
+ root: true,
+ });
+ this.dispatch(
+ "scenarioSettings/setBuiltInScenarios",
+ payload.built_in_scenarios,
+ { root: true }
+ );
+ if (payload.configuration !== null) {
+ state.is2d = payload.configuration.is2d;
+ this.dispatch(
+ "scenarioSettings/setScenario",
+ payload.configuration.scenarioSettings,
+ { root: true }
+ );
+ this.dispatch(
+ "displaySettings/setDisplaySettings",
+ payload.configuration.displaySettings,
+ {
+ root: true,
+ }
+ );
+ this.dispatch(
+ "transducersSettings/setTransducers",
+ payload.configuration.transducers,
+ {
+ root: true,
+ }
+ );
+ this.dispatch(
+ "simulationSettings/setSimulationSettings",
+ payload.configuration.simulationSettings,
+ {
+ root: true,
+ }
+ );
+ this.dispatch(
+ "targetSettings/setTarget",
+ payload.configuration.target,
+ {
+ root: true,
+ }
+ );
+ }
+ if (state.hasSimulation || state.isRunningSimulation) {
+ this.dispatch("getSimulation");
+ }
+ },
+ setHasSimulation(state, payload) {
+ state.hasSimulation = payload;
+ },
+ setRenderedOutput(state, payload) {
+ state.renderedOutput = payload;
+ },
+ setIsRunningSimulation(state, payload) {
+ state.isRunningSimulation = payload;
+ },
+ setProcessingMessage(state, payload) {
+ state.processingMessage = payload;
+ },
+ setIsProcessing(state, payload) {
+ state.isProcessing = payload;
+ },
+ },
+ actions: {
+ updateValidityState({ commit }, { component, isValid }) {
+ commit("setComponentValidity", { component, isValid });
+ },
+ setIsProcessing({ commit }, payload) {
+ commit("setIsProcessing", payload);
+ },
+ setProcessingMessage({ commit }, payload) {
+ commit("setProcessingMessage", payload);
+ },
+ reset({ commit }) {
+ // Reset root state
+ commit("setRenderedOutput", null);
+
+ commit("reset");
+
+ // Reset each submodule
+ commit("displaySettings/reset", null, { root: true });
+ commit("scenarioSettings/reset", null, { root: true });
+ commit("simulationSettings/reset", null, { root: true });
+ commit("targetSettings/reset", null, { root: true });
+ commit("transducersSettings/reset", null, { root: true });
+ },
+ set2d({ commit, dispatch }, payload) {
+ commit("set2d", payload);
+ dispatch("reset");
+ },
+ async getInitialData({ commit }) {
+ await fetch(`http://${process.env.VUE_APP_BACKEND_URL}/info`)
+ .then((response) => {
+ if (response.ok) {
+ return response.json();
+ }
+ throw new Error("Network response was not ok.");
+ })
+ .then((data) => {
+ commit("setInitialValues", data);
+ })
+ .catch((error) => {
+ console.error("Error:", error);
+ });
+ },
+ async runSimulation({ commit, dispatch }) {
+ commit("setRenderedOutput", null);
+ commit("setIsRunningSimulation", true);
+ commit("setIsProcessing", true);
+ commit("setProcessingMessage", "Running simulation...");
+ const payload = await dispatch("getPayload");
+
+ await fetch(`http://${process.env.VUE_APP_BACKEND_URL}/simulation`, {
+ method: "POST",
+ headers: new Headers({
+ "Content-Type": "application/json",
+ }),
+ body: JSON.stringify(payload),
+ })
+ .then((response) => {
+ if (!response.ok) {
+ return Promise.reject(response);
+ }
+ return response.json();
+ })
+ .then((data) => {
+ if (data) {
+ commit("setHasSimulation", true);
+ commit("setRenderedOutput", data.data);
+ commit("setIsRunningSimulation", false);
+ commit("setIsProcessing", false);
+ }
+ })
+ .catch((response) => {
+ commit("setIsProcessing", false);
+ response.json().then((error) => {
+ console.error(
+ "There was a problem with the fetch operation:",
+ error
+ );
+ });
+ });
+ },
+ async cleanSimulation({ commit }) {
+ // call the backend to cancel the simulation
+ try {
+ const response = await fetch(
+ `http://${process.env.VUE_APP_BACKEND_URL}/simulation`,
+ {
+ method: "DELETE",
+ }
+ );
+
+ if (!response.ok) {
+ throw new Error(`HTTP error! status: ${response.status}`);
+ }
+ } catch (error) {
+ console.error("There was a problem with the fetch operation:", error);
+ }
+ commit("setRenderedOutput", null);
+ commit("setHasSimulation", false);
+ commit("setIsRunningSimulation", false);
+ EventBus.emit("reset-parameters-panel");
+ },
+ getPayload({ state, rootGetters }) {
+ const body = {
+ is2d: state.is2d,
+ scenarioSettings:
+ rootGetters["scenarioSettings/scenarioSettingsPayload"],
+ transducers: rootGetters["transducersSettings/transducers"],
+ target: rootGetters["targetSettings/targetPayload"],
+ simulationSettings:
+ rootGetters["simulationSettings/simulationSettings"],
+ displaySettings: rootGetters["displaySettings/displaySettings"],
+ };
+ return body;
+ },
+ async renderLayout({ commit, dispatch, getters }) {
+ // Check if we have enough data to render the layout
+ if (
+ !getters.canRenderLayout ||
+ getters.hasSimulation ||
+ getters.isRunningSimulation
+ )
+ return;
+ EventBus.emit("validate");
+ if (!getters.areAllComponentsValid) {
+ return;
+ }
+ commit("setIsProcessing", true);
+ commit("setRenderedOutput", null);
+ commit("setProcessingMessage", "Rendering layout...");
+ const payload = await dispatch("getPayload");
+ try {
+ const response = await fetch(
+ `http://${process.env.VUE_APP_BACKEND_URL}/render_layout`,
+ {
+ method: "POST",
+ headers: new Headers({
+ "Content-Type": "application/json",
+ }),
+ body: JSON.stringify(payload),
+ }
+ );
+
+ if (!response.ok) {
+ throw new Error(`HTTP error! status: ${response.status}`);
+ }
+
+ const data = await response.json();
+ commit("setRenderedOutput", data.data);
+ commit("setIsProcessing", false);
+ } catch (error) {
+ commit("setIsProcessing", false);
+ console.error("There was a problem with the fetch operation:", error);
+ }
+ },
+ async getSimulation({ commit }) {
+ commit("setRenderedOutput", null);
+ commit("setIsRunningSimulation", true);
+ commit("setIsProcessing", true);
+ commit("setProcessingMessage", "Running simulation...");
+ try {
+ const response = await fetch(
+ `http://${process.env.VUE_APP_BACKEND_URL}/simulation`,
+ {
+ method: "GET",
+ }
+ );
+
+ if (!response.ok) {
+ throw new Error(`HTTP error! status: ${response.status}`);
+ }
+
+ const data = await response.json();
+ commit("setRenderedOutput", data.data);
+ commit("setHasSimulation", true);
+ commit("setIsRunningSimulation", false);
+ commit("setIsProcessing", false);
+ } catch (error) {
+ console.error("There was a problem with the fetch operation:", error);
+ commit("setIsProcessing", false);
+ }
+ },
+ },
+ getters: {
+ areAllComponentsValid(state) {
+ for (const key in state.validity) {
+ if (!state.validity[key]) {
+ if (key === "display" && state.is2d) {
+ continue;
+ }
+ EventBus.emit("open-panel", key);
+ return false;
+ }
+ }
+ return true;
+ },
+ canRenderLayout(state, getters) {
+ return getters["scenarioSettings/isScenarioValid"];
+ },
+ canRunSimulation(state, getters, _rootState, rootGetters) {
+ const isScenarioValid = getters["scenarioSettings/isScenarioValid"];
+ const transducers =
+ rootGetters["transducersSettings/transducers"].length > 0;
+ return isScenarioValid && transducers && !state.isRunningSimulation;
+ },
+ renderedOutput(state) {
+ return state.renderedOutput;
+ },
+ isRunningSimulation(state) {
+ return state.isRunningSimulation;
+ },
+ isProcessing(state) {
+ return state.isProcessing;
+ },
+ processingMessage(state) {
+ return state.processingMessage;
+ },
+ hasSimulation(state) {
+ return state.hasSimulation;
+ },
+ is2d(state) {
+ return state.is2d;
+ },
+ },
+});
+
+const debouncedRenderLayout = debounce(() => {
+ store.dispatch("renderLayout");
+}, 500);
+
+store.subscribe((mutation) => {
+ const namespaces = [
+ "displaySettings/",
+ "targetSettings/",
+ "transducersSettings/",
+ "simulationSettings/",
+ "scenarioSettings/",
+ ];
+
+ const isNamespaceMutation = namespaces.some((namespace) =>
+ mutation.type.startsWith(namespace)
+ );
+
+ if (isNamespaceMutation) {
+ debouncedRenderLayout();
+ }
+});
+
+export default store;
diff --git a/src/web/app/src/store/modules/displaySettings.js b/src/web/app/src/store/modules/displaySettings.js
new file mode 100644
index 00000000..2f824942
--- /dev/null
+++ b/src/web/app/src/store/modules/displaySettings.js
@@ -0,0 +1,53 @@
+const initialState = () => ({
+ sliceAxis: "",
+ slicePosition: null,
+});
+export default {
+ namespaced: true,
+ state: initialState,
+ mutations: {
+ reset(state) {
+ Object.assign(state, initialState());
+ },
+ setSliceAxis(state, payload) {
+ state.sliceAxis = payload;
+ },
+ setSlicePosition(state, payload) {
+ state.slicePosition = payload;
+ },
+ },
+ actions: {
+ setDisplaySettings(context, payload) {
+ if (payload === null) {
+ context.commit("setSliceAxis", "");
+ context.commit("setSlicePosition", null);
+ return;
+ }
+ context.commit("setSliceAxis", payload.sliceAxis);
+ context.commit("setSlicePosition", payload.slicePosition);
+ },
+ setSliceAxis(context, payload) {
+ context.commit("setSliceAxis", payload);
+ },
+ setSlicePosition(context, payload) {
+ context.commit("setSlicePosition", payload);
+ },
+ },
+ getters: {
+ sliceAxis(state) {
+ return state.sliceAxis;
+ },
+ slicePosition(state) {
+ return state.slicePosition;
+ },
+ displaySettings(state) {
+ if (state.sliceAxis === "" || state.slicePosition === null) {
+ return null;
+ }
+ return {
+ sliceAxis: state.sliceAxis,
+ slicePosition: state.slicePosition,
+ };
+ },
+ },
+};
diff --git a/src/web/app/src/store/modules/scenarioSettings.js b/src/web/app/src/store/modules/scenarioSettings.js
new file mode 100644
index 00000000..6b5964e1
--- /dev/null
+++ b/src/web/app/src/store/modules/scenarioSettings.js
@@ -0,0 +1,188 @@
+export default {
+ namespaced: true,
+ state() {
+ return {
+ scenarioId: null,
+ ctFile: null,
+ scenario: null,
+ isPreBuilt: true,
+ availableCTs: [],
+ builtInScenarios: [],
+ ctSliceAxis: "",
+ ctSlicePosition: null,
+ };
+ },
+ mutations: {
+ reset(state) {
+ state.scenarioId = null;
+ state.ctFile = null;
+ state.scenario = null;
+ state.ctSliceAxis = "";
+ state.ctSlicePosition = null;
+ },
+ setAvailableCTs(state, payload) {
+ state.availableCTs = payload;
+ },
+ setBuiltInScenarios(state, payload) {
+ state.builtInScenarios = payload;
+ },
+ setBuiltinScenario(state, payload) {
+ state.scenario = payload;
+ },
+ setIsPreBuilt(state, payload) {
+ state.isPreBuilt = payload;
+ },
+ setScenarioId(state, payload) {
+ state.scenarioId = payload;
+ },
+ setCTFile(state, payload) {
+ state.ctFile = payload;
+ },
+ setCtSliceAxis(state, payload) {
+ state.ctSliceAxis = payload;
+ },
+ setCtSlicePosition(state, payload) {
+ state.ctSlicePosition = payload;
+ },
+ },
+ actions: {
+ setBuiltInScenarios({ commit }, payload) {
+ commit("setBuiltInScenarios", payload);
+ },
+ setAvailableCTs({ commit }, payload) {
+ commit("setAvailableCTs", payload);
+ },
+ setCtSliceAxis({ commit }, payload) {
+ commit("setCtSliceAxis", payload);
+ },
+ setCtSlicePosition({ commit }, payload) {
+ commit("setCtSlicePosition", payload);
+ },
+ setCTFile({ commit }, payload) {
+ commit("setCTFile", payload);
+ },
+ setScenario({ dispatch, commit }, payload) {
+ commit("setIsPreBuilt", payload.isPreBuilt);
+ if (payload.isPreBuilt) {
+ dispatch("setBuiltinScenario", payload.scenarioId);
+ } else {
+ dispatch("setCtScenario", payload);
+ }
+ },
+ setCtScenario({ commit }, payload) {
+ commit("setCTFile", payload.ctFile);
+ if (payload.ctSliceAxis) {
+ commit("setCtSliceAxis", payload.ctSliceAxis);
+ commit("setCtSlicePosition", payload.ctSlicePosition);
+ }
+ },
+ setBuiltinScenario({ dispatch, commit, getters }, payload) {
+ // payload will have the scenario name, we need to iterate over the
+ // builtInScenarios to find the scenario and then set the scenario in the state
+ const scenarios = getters.builtInScenarios;
+ const scenario = scenarios[payload];
+ commit("setScenarioId", scenario.scenarioSettings.scenarioId);
+ commit("setBuiltinScenario", scenario);
+ dispatch("displaySettings/setDisplaySettings", scenario.displaySettings, {
+ root: true,
+ });
+ dispatch("transducersSettings/setTransducers", scenario.transducers, {
+ root: true,
+ });
+ dispatch(
+ "simulationSettings/setSimulationSettings",
+ scenario.simulationSettings,
+ {
+ root: true,
+ }
+ );
+ dispatch("targetSettings/setTarget", scenario.target, {
+ root: true,
+ });
+ },
+ setIsPreBuilt({ commit, dispatch }, payload) {
+ commit("setIsPreBuilt", payload);
+ dispatch("reset", null, { root: true });
+ },
+ },
+ getters: {
+ isScenarioValid(state, getters, rootState, { is2d }) {
+ if (state.isPreBuilt) {
+ return state.scenarioId !== null;
+ }
+ if (is2d) {
+ return (
+ state.ctFile !== null &&
+ state.ctSliceAxis !== "" &&
+ state.ctSlicePosition !== null
+ );
+ }
+ return state.ctFile !== null;
+ },
+ scenarioSettingsPayload(state, getters, rootState, { is2d }) {
+ const payload = {
+ isPreBuilt: state.isPreBuilt,
+ };
+
+ // If the scenario is pre-built, add the scenarioId and return the payload
+ if (state.isPreBuilt) {
+ payload.scenarioId = state.scenarioId;
+ return payload;
+ }
+
+ payload.ctFile = state.ctFile;
+
+ // If the scenario is 2D, also include the ctSliceAxis and ctSlicePosition
+ if (is2d) {
+ payload.ctSliceAxis = state.ctSliceAxis;
+ payload.ctSlicePosition = state.ctSlicePosition;
+ }
+
+ return payload;
+ },
+ scenario(state) {
+ return state.scenario;
+ },
+ scenarioId(state) {
+ return state.scenarioId;
+ },
+ isPreBuilt(state) {
+ return state.isPreBuilt;
+ },
+ availableCTs(state) {
+ return state.availableCTs;
+ },
+ ctFile(state) {
+ return state.ctFile;
+ },
+ ctSliceAxis(state) {
+ return state.ctSliceAxis;
+ },
+ ctSlicePosition(state) {
+ return state.ctSlicePosition;
+ },
+ builtInScenarios(state) {
+ return state.builtInScenarios;
+ },
+ builtInScenarios2d(state) {
+ const scenarios = state.builtInScenarios;
+ const filteredScenarios = Object.keys(scenarios)
+ .filter((key) => scenarios[key].is2d)
+ .reduce((obj, key) => {
+ obj[key] = scenarios[key];
+ return obj;
+ }, {});
+ return filteredScenarios;
+ },
+ builtInScenarios3d(state) {
+ const scenarios = state.builtInScenarios;
+ const filteredScenarios = Object.keys(scenarios)
+ .filter((key) => !scenarios[key].is2d)
+ .reduce((obj, key) => {
+ obj[key] = scenarios[key];
+ return obj;
+ }, {});
+ return filteredScenarios;
+ },
+ },
+};
diff --git a/src/web/app/src/store/modules/simulationSettings.js b/src/web/app/src/store/modules/simulationSettings.js
new file mode 100644
index 00000000..04fa0241
--- /dev/null
+++ b/src/web/app/src/store/modules/simulationSettings.js
@@ -0,0 +1,92 @@
+const initialState = () => ({
+ simulationPrecision: "6",
+ centerFrequency: "500000",
+ isSteadySimulation: true,
+ materialProperties: {
+ water: {
+ vp: "1500",
+ rho: "1000",
+ alpha: "0",
+ renderColor: "#2e86ab",
+ },
+ brain: {
+ vp: "1560",
+ rho: "1040",
+ alpha: "0.3",
+ renderColor: "#db504a",
+ },
+ corticalBone: {
+ vp: "2800",
+ rho: "1850",
+ alpha: "4",
+ renderColor: "#faf0ca",
+ },
+ tumor: {
+ vp: "1650",
+ rho: "1150",
+ alpha: "0.8",
+ renderColor: "#94332f",
+ },
+ },
+});
+export default {
+ namespaced: true,
+ state: initialState,
+ mutations: {
+ reset(state) {
+ Object.assign(state, initialState());
+ },
+ updateMaterialProperty(state, { material, prop, value }) {
+ if (state.materialProperties[material]) {
+ state.materialProperties[material][prop] = value;
+ }
+ },
+ setSimulationPrecision(state, payload) {
+ state.simulationPrecision = payload;
+ },
+ setCenterFrequency(state, payload) {
+ state.centerFrequency = payload;
+ },
+ setIsSteadySimulation(state, payload) {
+ state.isSteadySimulation = payload;
+ },
+ setSimulationSettings(state, payload) {
+ state.simulationPrecision = payload.simulationPrecision;
+ state.centerFrequency = payload.centerFrequency;
+ state.isSteadySimulation = payload.isSteadySimulation;
+ },
+ },
+ actions: {
+ setSimulationSettings({ commit }, payload) {
+ commit("setSimulationSettings", payload);
+ },
+ setSimulationPrecision({ commit }, payload) {
+ commit("setSimulationPrecision", payload);
+ },
+ setCenterFrequency({ commit }, payload) {
+ commit("setCenterFrequency", payload);
+ },
+ setIsSteadySimulation({ commit }, payload) {
+ commit("setIsSteadySimulation", payload);
+ },
+ },
+ getters: {
+ simulationPrecision(state) {
+ return state.simulationPrecision;
+ },
+ centerFrequency(state) {
+ return state.centerFrequency;
+ },
+ isSteadySimulation(state) {
+ return state.isSteadySimulation;
+ },
+ simulationSettings(state) {
+ return {
+ simulationPrecision: state.simulationPrecision,
+ centerFrequency: state.centerFrequency,
+ isSteadySimulation: state.isSteadySimulation,
+ materialProperties: state.materialProperties,
+ };
+ },
+ },
+};
diff --git a/src/web/app/src/store/modules/targetSettings.js b/src/web/app/src/store/modules/targetSettings.js
new file mode 100644
index 00000000..1c88f144
--- /dev/null
+++ b/src/web/app/src/store/modules/targetSettings.js
@@ -0,0 +1,54 @@
+const initialState = () => ({
+ centerX: null,
+ centerY: null,
+ centerZ: null,
+ radius: null,
+});
+export default {
+ namespaced: true,
+ state: initialState,
+ mutations: {
+ reset(state) {
+ Object.assign(state, initialState());
+ },
+ updateTargetProperty(state, payload) {
+ state[payload.key] = payload.value;
+ },
+ setTarget(state, payload) {
+ state.centerX = payload.centerX;
+ state.centerY = payload.centerY;
+ state.centerZ = payload.centerZ;
+ state.radius = payload.radius;
+ },
+ },
+ actions: {
+ updateTargetProperty({ commit }, payload) {
+ commit("updateTargetProperty", payload);
+ },
+ setTarget({ commit }, payload) {
+ commit("setTarget", payload);
+ },
+ },
+ getters: {
+ centerX(state) {
+ return state.centerX;
+ },
+ centerY(state) {
+ return state.centerY;
+ },
+ centerZ(state) {
+ return state.centerZ;
+ },
+ radius(state) {
+ return state.radius;
+ },
+ targetPayload(state, getters, rootState, { is2d }) {
+ return {
+ centerX: state.centerX,
+ centerY: state.centerY,
+ centerZ: is2d ? null : state.centerZ,
+ radius: state.radius,
+ };
+ },
+ },
+};
diff --git a/src/web/app/src/store/modules/transducersSettings.js b/src/web/app/src/store/modules/transducersSettings.js
new file mode 100644
index 00000000..121f19f7
--- /dev/null
+++ b/src/web/app/src/store/modules/transducersSettings.js
@@ -0,0 +1,36 @@
+export default {
+ namespaced: true,
+ state() {
+ return {
+ transducers: [],
+ };
+ },
+ mutations: {
+ reset() {},
+ setTransducers(state, payload) {
+ state.transducers = payload;
+ },
+ deleteTransducer(state, index) {
+ state.transducers.splice(index, 1);
+ },
+ updateTransducer(state, { index, settings }) {
+ state.transducers[index] = { ...state.transducers[index], ...settings };
+ },
+ addTransducer(state, transducerSettings) {
+ state.transducers.push(transducerSettings);
+ },
+ },
+ actions: {
+ setTransducers(context, payload) {
+ context.commit("setTransducers", payload);
+ },
+ addTransducer({ commit }, transducerSettings) {
+ commit("addTransducer", transducerSettings);
+ },
+ },
+ getters: {
+ transducers(state) {
+ return state.transducers;
+ },
+ },
+};
diff --git a/src/web/app/vue.config.js b/src/web/app/vue.config.js
new file mode 100644
index 00000000..910e297e
--- /dev/null
+++ b/src/web/app/vue.config.js
@@ -0,0 +1,4 @@
+const { defineConfig } = require('@vue/cli-service')
+module.exports = defineConfig({
+ transpileDependencies: true
+})
diff --git a/src/web/computed_tomography.py b/src/web/computed_tomography.py
new file mode 100644
index 00000000..d7ef2208
--- /dev/null
+++ b/src/web/computed_tomography.py
@@ -0,0 +1,224 @@
+"""Contains functions for loading Computed Tomography images and their masks."""
+import json
+import pathlib
+import tempfile
+import zipfile
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple, Union
+
+import nibabel as nib
+import numpy as np
+import pydicom
+from nibabel.nifti1 import Nifti1Image
+from nibabel.nifti2 import Nifti2Image
+from web.messages.settings import Axis
+
+from neurotechdevkit.materials import DEFAULT_MATERIALS
+
+
+@dataclass
+class ComputedTomographyImage:
+ """A Computed Tomography image with its voxel spacing and material masks."""
+
+ data: np.ndarray
+ spacing: Tuple[float, float, float] # voxel sizes in millimeter
+ material_masks: Dict[str, np.ndarray]
+
+ @property
+ def spacing_in_meters(self) -> Tuple[float, ...]:
+ """The voxel spacing in meters."""
+ return tuple(s / 1000 for s in self.spacing)
+
+
+@dataclass
+class ComputedTomographyInfo:
+ """Information about a Computed Tomography."""
+
+ filename: str
+ shape: Tuple[int, ...]
+ spacing: str # We need to convert the tuple to a string to be able to serialize it.
+
+
+def _assign_masks(mapping: dict[str, int], data: np.ndarray) -> Dict[str, np.ndarray]:
+ """Assign the masks to the materials.
+
+ Args:
+ mapping: A dictionary mapping material names to label values.
+ data: The Computed Tomography image data.
+
+ Returns:
+ A dictionary of material masks with material names as keys.
+ """
+ mask_materials: Dict[str, np.ndarray] = {}
+ for material, label_value in mapping.items():
+ label_mask = data == label_value
+ mask_materials[material] = label_mask.astype(np.bool_)
+
+ return mask_materials
+
+
+def _load_nii(filepath: pathlib.Path) -> Tuple[np.ndarray, Tuple[float, float, float]]:
+ """Load a NIfTI file.
+
+ Args:
+ filepath: Path to the NIfTI file.
+
+ Returns:
+ A tuple containing the image data and the voxel spacing.
+ """
+ image: Union[Nifti1Image, Nifti2Image] = nib.load(filepath) # type: ignore
+ return image.get_fdata(), image.header.get_zooms()
+
+
+def _load_compacted_dicom(
+ filepath: pathlib.Path,
+) -> Tuple[np.ndarray, Tuple[float, float, float]]:
+ """Extract and load the dicom files from a zip file.
+
+ Args:
+ filepath: Path to the zip file.
+
+ Returns:
+ A tuple containing the image data and the voxel spacing.
+ """
+ with tempfile.TemporaryDirectory() as tmpdir:
+ with zipfile.ZipFile(filepath, "r") as zip_ref:
+ zip_ref.extractall(tmpdir)
+ dicom_files = list(pathlib.Path(tmpdir).glob("*.dcm"))
+ dicom_files.sort()
+ dicom_data = []
+ for dicom_file in dicom_files:
+ data = pydicom.dcmread(dicom_file, force=True)
+ dicom_data.append(data)
+
+ image = np.stack([dicom.pixel_array for dicom in dicom_data])
+ spacing = (
+ float(dicom_data[0].PixelSpacing[0]),
+ float(dicom_data[0].PixelSpacing[1]),
+ float(dicom_data[0].SliceThickness),
+ )
+ return image, spacing
+
+
+def _load_ct_file(
+ ct_path: pathlib.Path,
+) -> Tuple[np.ndarray, Tuple[float, float, float]]:
+ """Load a CT image file.
+
+ Args:
+ ct_path: Path to the CT image file.
+
+ Returns:
+ A tuple containing the image data and the voxel spacing.
+ """
+ if ct_path.suffix == ".nii":
+ return _load_nii(ct_path)
+ elif ct_path.suffix == ".zip":
+ return _load_compacted_dicom(ct_path)
+ else:
+ raise ValueError(f"Unsupported CT file type: {ct_path.suffix}")
+
+
+def _load_mapping_file(mapping_path: pathlib.Path) -> dict[str, int]:
+ """Load the mapping file.
+
+ Args:
+ mapping_path: Path to the mapping file.
+
+ Returns:
+ A dictionary mapping material names to label values.
+ """
+ with open(mapping_path, "r") as f:
+ try:
+ return json.load(f)
+ except json.JSONDecodeError:
+ raise ValueError(
+ f"Could not load masks file {mapping_path.name} as JSON."
+ ) from None
+
+
+def get_ct_image(
+ ct_path: pathlib.Path,
+ slice_axis: Optional[Axis],
+ slice_position: Optional[float],
+) -> ComputedTomographyImage:
+ """Load a CT image and its masks.
+
+ Args:
+ ct_path: Path to the CT image file.
+ slice_axis: The axis along which to slice the image.
+ slice_position: The position along the slice axis.
+
+ Returns:
+ A ComputedTomographyImage object.
+ """
+ array, spacing = _load_ct_file(ct_path)
+ mapping = _load_mapping_file(ct_path.with_suffix(".json"))
+
+ if slice_axis is not None and slice_position is not None:
+ if slice_axis == Axis.x:
+ position = int(slice_position / spacing[0] * 1000)
+ array = array[position, :, :]
+ elif slice_axis == Axis.y:
+ position = int(slice_position / spacing[1] * 1000)
+ array = array[:, position, :]
+ elif slice_axis == Axis.z:
+ position = int(slice_position / spacing[2] * 1000)
+ array = array[:, :, position]
+
+ material_masks = _assign_masks(mapping, array)
+ return ComputedTomographyImage(
+ data=array, spacing=spacing, material_masks=material_masks
+ )
+
+
+def get_available_cts(cts_folder: pathlib.Path) -> List[ComputedTomographyInfo]:
+ """Get the list of available Computed Tomography's in the given directory.
+
+ Args:
+ cts_folder: Path to the folder containing the Computed Tomography's.
+
+ Returns:
+ The list of available Computed Tomography's.
+ """
+ files: List[ComputedTomographyInfo] = []
+ for file in cts_folder.glob("**/*"):
+ if file.is_file() and file.suffix in [".nii", ".zip"]:
+ ct, spacing = _load_ct_file(file)
+ ct_info = ComputedTomographyInfo(
+ filename=file.name, shape=ct.shape, spacing=str(list(spacing))
+ )
+ files.append(ct_info)
+ return files
+
+
+def validate_ct(directory: pathlib.Path, files: list[str]) -> ComputedTomographyInfo:
+ """Validate the CT image and its masks.
+
+ Args:
+ directory: Path to the directory containing the CT image and its masks.
+ files: List of files in the directory to be checked.
+
+ Returns:
+ The ComputedTomographyInfo object.
+ """
+ assert (
+ len(files) == 2
+ ), f"Expected exactly two files but found {len(files)}: {files}"
+ ct_file, mapping_file = (
+ (files[0], files[1]) if files[1].endswith(".json") else (files[1], files[0])
+ )
+ data, spacing = _load_ct_file(directory / ct_file)
+ mapping = _load_mapping_file(directory / mapping_file)
+ data_layers = set(np.unique(data).astype(np.int_))
+ assert data_layers == set(mapping.values()), (
+ "The labels in the CT image do not match the labels in the masks file."
+ f"Expected labels: {data_layers}"
+ )
+
+ for material in mapping.keys():
+ if material not in DEFAULT_MATERIALS:
+ raise ValueError(f"Material {material} is not supported.")
+ return ComputedTomographyInfo(
+ filename=ct_file, shape=data.shape, spacing=str(list(spacing))
+ )
diff --git a/src/web/controller.py b/src/web/controller.py
new file mode 100644
index 00000000..8dc5b446
--- /dev/null
+++ b/src/web/controller.py
@@ -0,0 +1,302 @@
+"""Controller for the web app."""
+import base64
+import io
+import tempfile
+from typing import Dict, Optional, Tuple, Union
+
+import codepy
+import matplotlib.pyplot as plt
+from flask import current_app
+from web.computed_tomography import get_ct_image
+from web.messages.material_properties import Material, MaterialName, MaterialProperties
+from web.messages.requests import (
+ IndexBuiltInScenario,
+ RenderLayoutRequest,
+ SimulateRequest,
+)
+from web.messages.settings import Axis
+
+from neurotechdevkit.grid import Grid
+from neurotechdevkit.materials import DEFAULT_MATERIALS, get_material
+from neurotechdevkit.results import SteadyStateResult2D, SteadyStateResult3D
+from neurotechdevkit.scenarios import Scenario2D, Scenario3D
+from neurotechdevkit.scenarios.built_in import BUILT_IN_SCENARIOS
+
+
+class Error(Exception):
+ """Base class for exceptions in this module."""
+
+ def __str__(self):
+ """Return the exception message."""
+ return self.message
+
+
+class CompilationError(Error):
+ """Exception raised for errors in the compilation of a scenario."""
+
+ def __init__(self):
+ """Initialize the exception."""
+ self.message = "Compilation error"
+
+
+class BuiltInScenariosShelf(object):
+ """Singleton class for storing the already instantiated built-in scenarios."""
+
+ scenarios: Dict[str, Dict[float, Union[Scenario2D, Scenario3D]]] = {}
+
+ def __new__(cls):
+ """Create a new instance of the BuiltInScenariosShelf class."""
+ if not hasattr(cls, "instance"):
+ cls.instance = super(BuiltInScenariosShelf, cls).__new__(cls)
+ return cls.instance
+
+ def get(
+ self, scenario_id: str, center_frequency: float
+ ) -> Union[Scenario2D, Scenario3D]:
+ """
+ Return the instantiated built-in scenario with the given id.
+
+ Args:
+ scenario_id: The id of the scenario.
+
+ Returns:
+ The built-in scenario.
+ """
+ if scenario_id not in self.scenarios:
+ self.scenarios[scenario_id] = {}
+
+ if center_frequency not in self.scenarios[scenario_id]:
+ builtin_scenario = BUILT_IN_SCENARIOS[scenario_id]()
+ builtin_scenario.center_frequency = center_frequency
+ builtin_scenario.make_grid()
+ builtin_scenario.compile_problem()
+ self.scenarios[scenario_id][center_frequency] = builtin_scenario
+ return self.scenarios[scenario_id][center_frequency]
+
+
+def get_built_in_scenarios() -> Dict[str, Dict]:
+ """
+ Return a dictionary containing information about all the built-in scenarios.
+
+ Returns:
+ The dictionary of built-in scenario info.
+ """
+ scenarios = {}
+ for scenario_id, scenario in BUILT_IN_SCENARIOS.items():
+ assert issubclass(scenario, (Scenario2D, Scenario3D))
+ settings = IndexBuiltInScenario.from_scenario(scenario_id, scenario)
+ assert isinstance(settings, IndexBuiltInScenario)
+ settings.title = scenario_id.replace("_", " ").title()
+ scenarios[scenario_id] = settings.dict()
+ return scenarios
+
+
+def get_scenario_layout(config: RenderLayoutRequest) -> str:
+ """
+ Render the layout of a scenario and return the result as a base64 png.
+
+ Args:
+ config (RenderLayoutRequest): The configuration for the scenario.
+
+ Returns:
+ The base64 encoded png image.
+ """
+ scenario = _instantiate_scenario(
+ config.scenarioSettings.isPreBuilt,
+ config.is2d,
+ config.scenarioSettings.scenario_id,
+ config.simulationSettings.centerFrequency,
+ )
+ if not config.scenarioSettings.isPreBuilt:
+ assert config.scenarioSettings.ctFile is not None
+ ct_image = get_ct_image(
+ ct_path=current_app.config["CT_FOLDER"] / config.scenarioSettings.ctFile,
+ slice_axis=config.scenarioSettings.ctSliceAxis,
+ slice_position=config.scenarioSettings.ctSlicePosition,
+ )
+ spacing = ct_image.spacing_in_meters
+ if config.is2d:
+ assert config.scenarioSettings.ctSliceAxis is not None
+ if config.scenarioSettings.ctSliceAxis == Axis.x:
+ spacing = (spacing[1], spacing[2])
+ elif config.scenarioSettings.ctSliceAxis == Axis.y:
+ spacing = (spacing[0], spacing[2])
+ else:
+ spacing = spacing = (spacing[0], spacing[1])
+ scenario.grid = Grid.make_shaped_grid(
+ shape=ct_image.data.shape, spacing=spacing
+ )
+ scenario.material_masks = ct_image.material_masks
+ _configure_scenario(scenario, config)
+ fig = scenario.render_layout(show_sources=len(scenario.sources) > 0)
+ buf = io.BytesIO()
+ fig.savefig(buf, format="png")
+ data = base64.b64encode(buf.getbuffer()).decode("ascii")
+ plt.close(fig)
+ return data
+
+
+def _instantiate_scenario(
+ is_prebuilt: bool,
+ is_2d: bool,
+ scenario_id: Optional[str],
+ center_frequency: float,
+) -> Union[Scenario2D, Scenario3D]:
+ """Instantiate the scenario for the web app.
+
+ Args:
+ is_prebuilt: Whether the scenario is pre-built or not.
+ is_2d: Whether the scenario is 2D or not.
+ scenario_id: The id of the scenario.
+ center_frequency: The center frequency of the scenario.
+
+ Returns:
+ The instantiated scenario.
+ """
+ if is_prebuilt:
+ assert scenario_id is not None
+ builtin_scenario = BuiltInScenariosShelf().get(scenario_id, center_frequency)
+ material_properties = {
+ key: value for key, value in builtin_scenario.material_properties.items()
+ }
+ sources = []
+ if (
+ hasattr(builtin_scenario, "sources")
+ and builtin_scenario.sources is not None
+ ):
+ for source in builtin_scenario.sources:
+ sources.append(source)
+
+ scenario_class = Scenario2D if is_2d else Scenario3D
+ scenario = scenario_class(
+ center_frequency=builtin_scenario.center_frequency,
+ material_properties=material_properties,
+ material_masks=builtin_scenario.material_masks,
+ material_outline_upsample_factor=16, # TODO: make this configurable
+ origin=builtin_scenario.origin,
+ sources=sources,
+ target=builtin_scenario.target,
+ problem=builtin_scenario.problem,
+ grid=builtin_scenario.grid,
+ )
+ else:
+ scenario_class = Scenario2D if is_2d else Scenario3D
+ scenario = scenario_class(
+ sources=[],
+ origin=[0, 0] if is_2d else [0, 0, 0],
+ material_outline_upsample_factor=16, # TODO: make this configurable
+ )
+
+ return scenario
+
+
+async def get_simulation_image(
+ config: SimulateRequest, app_config: dict
+) -> Union[Error, Tuple[str, str]]:
+ """
+ Simulate a scenario and return the result as a base64 GIF or PNG.
+
+ Args:
+ config (SimulateRequest): The configuration for the scenario.
+ app_config(dict): The configuration of the app.
+
+ Returns:
+ Tuple[str, str]: The base64 encoded image and the image format.
+ """
+ scenario = _instantiate_scenario(
+ config.scenarioSettings.isPreBuilt,
+ config.is2d,
+ config.scenarioSettings.scenario_id,
+ config.simulationSettings.centerFrequency,
+ )
+ if not config.scenarioSettings.isPreBuilt:
+ assert config.scenarioSettings.ctFile is not None
+ ct_image = get_ct_image(
+ ct_path=app_config["CT_FOLDER"] / config.scenarioSettings.ctFile,
+ slice_axis=config.scenarioSettings.ctSliceAxis,
+ slice_position=config.scenarioSettings.ctSlicePosition,
+ )
+ scenario.grid = Grid.make_shaped_grid(
+ shape=ct_image.data.shape, spacing=ct_image.spacing[0] / 1000
+ )
+ scenario.material_masks = ct_image.material_masks
+ _configure_scenario(scenario, config)
+ scenario.compile_problem()
+ if config.simulationSettings.isSteadySimulation:
+ try:
+ result = scenario.simulate_steady_state()
+ except codepy.CompileError:
+ return CompilationError()
+
+ assert isinstance(result, (SteadyStateResult2D, SteadyStateResult3D))
+ fig = result.render_steady_state_amplitudes(show_material_outlines=False)
+ buf = io.BytesIO()
+ fig.savefig(buf, format="png")
+ data = base64.b64encode(buf.getbuffer()).decode("ascii")
+ plt.close(fig)
+ return data, "png"
+ else:
+ try:
+ pulse_result = scenario.simulate_pulse()
+ except codepy.CompileError:
+ return CompilationError()
+
+ animation = pulse_result.render_pulsed_simulation_animation()
+ assert hasattr(animation, "_fig")
+ with tempfile.NamedTemporaryFile(suffix=".gif") as tmpfile:
+ animation.save(tmpfile.name, writer="imagemagick", fps=30)
+ tmpfile.seek(0)
+ buf = io.BytesIO(tmpfile.read())
+ data = base64.b64encode(buf.getbuffer()).decode("ascii")
+ plt.close(animation._fig)
+ return data, "gif"
+
+
+def get_default_material_properties(center_frequency: float) -> MaterialProperties:
+ """Get the default material properties with center frequency.
+
+ Args:
+ center_frequency: The center frequency of the scenario.
+
+ Returns:
+ The default material properties.
+ """
+ material_properties = {}
+ for ndk_material_name in DEFAULT_MATERIALS:
+ ndk_material = get_material(ndk_material_name, center_frequency)
+ material = Material.from_ndk_material(ndk_material)
+ material_name = MaterialName.get_material_name(ndk_material_name)
+ material_properties[material_name] = material
+
+ return MaterialProperties(**material_properties)
+
+
+def _configure_scenario(
+ scenario: Union[Scenario2D, Scenario3D],
+ config: Union[RenderLayoutRequest, SimulateRequest],
+):
+ """Configure a scenario based on the given configuration.
+
+ Args:
+ scenario: The scenario to configure.
+ config: The configuration.
+ """
+ scenario.center_frequency = config.simulationSettings.centerFrequency
+ if config_target := config.target:
+ scenario.target = config_target.to_ndk_target()
+
+ if isinstance(scenario, Scenario3D) and config.displaySettings:
+ scenario.slice_axis = config.displaySettings.sliceAxis.to_ndk_axis()
+ scenario.slice_position = config.displaySettings.slicePosition
+
+ config_material_properties = config.simulationSettings.materialProperties
+ if config_material_properties:
+ scenario.material_properties = (
+ config_material_properties.to_ndk_material_properties()
+ )
+
+ config_transducers = config.transducers
+ scenario.sources.clear()
+ for configured_transducer in config_transducers:
+ source = configured_transducer.to_ndk_source()
+ scenario.sources.append(source)
diff --git a/src/web/messages/__init__.py b/src/web/messages/__init__.py
new file mode 100644
index 00000000..1ddb844a
--- /dev/null
+++ b/src/web/messages/__init__.py
@@ -0,0 +1 @@
+"""Contain the messages for the web app."""
diff --git a/src/web/messages/material_properties.py b/src/web/messages/material_properties.py
new file mode 100644
index 00000000..f4196a8b
--- /dev/null
+++ b/src/web/messages/material_properties.py
@@ -0,0 +1,112 @@
+"""Pydantic models for the material properties."""
+from enum import Enum
+from typing import Dict, List, Optional, Tuple, Union
+
+from pydantic import BaseModel, create_model
+
+from neurotechdevkit.materials import Material as NDKMaterial
+from neurotechdevkit.scenarios import Scenario2D, Scenario3D
+
+
+class Material(BaseModel):
+ """Material model for the material properties."""
+
+ vp: float
+ rho: float
+ alpha: float
+ renderColor: str
+
+ @classmethod
+ def from_ndk_material(cls, material: NDKMaterial) -> "Material":
+ """Instantiate the web material from an NDKMaterial."""
+ return cls(
+ vp=material.vp,
+ rho=material.rho,
+ alpha=material.alpha,
+ renderColor=material.render_color,
+ )
+
+ def to_ndk_material(self) -> NDKMaterial:
+ """Instantiate the NDKMaterial from the web material."""
+ return NDKMaterial(
+ vp=self.vp,
+ rho=self.rho,
+ alpha=self.alpha,
+ render_color=self.renderColor,
+ )
+
+
+class MaterialName(Enum):
+ """Enum to map the material names between the web and NDK."""
+
+ water = "water"
+ brain = "brain"
+ trabecularBone = "trabecular_bone"
+ corticalBone = "cortical_bone"
+ skin = "skin"
+ tumor = "tumor"
+ agarHydrogel = "agar_hydrogel"
+
+ @classmethod
+ def get_material_titles(cls) -> List[Tuple[str, str]]:
+ """Get the material names and titles.
+
+ Returns:
+ The list of material names and titles.
+ """
+ titles = []
+ for material_name in cls:
+ title = material_name.value.replace("_", " ").title()
+ titles.append((material_name.name, title))
+ return titles
+
+ @classmethod
+ def get_material_name(cls, ndk_material_name: str) -> str:
+ """Get the material name from the NDK material name."""
+ for material_name in MaterialName:
+ if material_name.value == ndk_material_name:
+ return material_name.name
+ raise ValueError(f"Material name {ndk_material_name} not found.")
+
+ @classmethod
+ def get_ndk_material_name(cls, material_name: str) -> str:
+ """Get the NDK material name from the material name."""
+ for material in MaterialName:
+ if material.name == material_name:
+ return material.value
+ raise ValueError(f"Material name {material_name} not found.")
+
+
+_MaterialProperties: BaseModel = create_model( # type: ignore
+ "MaterialProperties",
+ **{
+ material_name.name: (Optional[Material], None) for material_name in MaterialName
+ },
+)
+
+
+class MaterialProperties(_MaterialProperties): # type: ignore
+ """Material properties model for the material properties."""
+
+ def to_ndk_material_properties(self) -> Dict[str, NDKMaterial]:
+ """Instantiate the NDKMaterialProperties from the web material properties."""
+ ndk_material_properties = {}
+ for material_name in self.__fields__:
+ if material := getattr(self, material_name):
+ ndk_material = material.to_ndk_material()
+ ndk_material_name = MaterialName.get_ndk_material_name(material_name)
+ ndk_material_properties[ndk_material_name] = ndk_material
+ return ndk_material_properties
+
+ @classmethod
+ def from_scenario(
+ cls, scenario: Union[Scenario2D, Scenario3D]
+ ) -> "MaterialProperties":
+ """Instantiate the web material properties from a scenario."""
+ material_properties = {}
+ ndk_material_properties = scenario.material_properties
+ for ndk_material_name, ndk_material in ndk_material_properties.items():
+ material = Material.from_ndk_material(ndk_material)
+ material_name = MaterialName.get_material_name(ndk_material_name)
+ material_properties[material_name] = material
+ return cls(**material_properties)
diff --git a/src/web/messages/requests.py b/src/web/messages/requests.py
new file mode 100644
index 00000000..09a576e7
--- /dev/null
+++ b/src/web/messages/requests.py
@@ -0,0 +1,22 @@
+"""Request models for the web messages sent and received by the web app."""
+from typing import Optional
+
+from web.messages.settings import DefaultSettings
+
+
+class RenderLayoutRequest(DefaultSettings):
+ """Render layout request model for the render layout request."""
+
+ pass
+
+
+class SimulateRequest(DefaultSettings):
+ """Simulate request model for the simulate request."""
+
+ pass
+
+
+class IndexBuiltInScenario(DefaultSettings):
+ """The Scenario settings for the index page."""
+
+ title: Optional[str] = None
diff --git a/src/web/messages/settings.py b/src/web/messages/settings.py
new file mode 100644
index 00000000..447bea4c
--- /dev/null
+++ b/src/web/messages/settings.py
@@ -0,0 +1,165 @@
+"""Pydantic models for the scenario settings."""
+from enum import Enum
+from typing import Optional, Type, Union
+
+from pydantic import BaseModel, validator
+from web.messages.material_properties import MaterialProperties
+from web.messages.transducers import TRANSDUCER_SETTINGS, Transducer
+
+from neurotechdevkit.scenarios import Scenario2D, Scenario3D, SliceAxis
+from neurotechdevkit.scenarios import Target as NDKTarget
+
+
+class Axis(str, Enum):
+ """Axis enum for the axis of Computed Tomography scans."""
+
+ x = "x"
+ y = "y"
+ z = "z"
+
+ @classmethod
+ def from_ndk_axis(cls, axis: Optional[SliceAxis]) -> Optional["Axis"]:
+ """Get the axis from the NDK axis."""
+ if axis == SliceAxis.X:
+ return cls.x
+ elif axis == SliceAxis.Y:
+ return cls.y
+ elif axis == SliceAxis.Z:
+ return cls.z
+ return None
+
+ def to_ndk_axis(self) -> SliceAxis:
+ """Get the NDK axis from the axis."""
+ if self == self.x:
+ return SliceAxis.X
+ elif self == self.y:
+ return SliceAxis.Y
+ elif self == self.z:
+ return SliceAxis.Z
+ raise ValueError(f"Invalid axis: {self}")
+
+
+class Target(BaseModel):
+ """Target model for the target settings."""
+
+ centerX: float
+ centerY: float
+ centerZ: Optional[float]
+ radius: float
+
+ def to_ndk_target(self) -> NDKTarget:
+ """Get the NDK target from the target."""
+ center = [self.centerX, self.centerY]
+ if self.centerZ is not None:
+ center.append(self.centerZ)
+ return NDKTarget(
+ target_id="target_1",
+ center=center,
+ radius=self.radius,
+ description="",
+ )
+
+ @classmethod
+ def from_ndk_target(cls, target: NDKTarget) -> "Target":
+ """Get the target from the NDK target."""
+ return cls(
+ centerX=target.center[0],
+ centerY=target.center[1],
+ centerZ=target.center[2] if len(target.center) > 2 else None,
+ radius=target.radius,
+ )
+
+
+class DisplaySettings(BaseModel):
+ """Display settings model for slicing when running 3D simulations."""
+
+ sliceAxis: Axis
+ slicePosition: float
+
+
+class ScenarioSettings(BaseModel):
+ """Scenario settings model for the scenario settings."""
+
+ isPreBuilt: bool
+ scenarioId: Optional[str]
+ ctFile: Optional[str]
+ ctSliceAxis: Optional[Axis]
+ ctSlicePosition: Optional[float]
+
+ @validator("scenarioId", always=True)
+ def _validate(cls, value, values):
+ if values.get("isPreBuilt") and not value:
+ raise ValueError("scenarioId is required for prebuilt scenarios")
+ return value
+
+ @property
+ def scenario_id(self) -> Optional[str]:
+ """Get the scenario id."""
+ return self.scenarioId
+
+
+class SimulationSettings(BaseModel):
+ """Simulation settings model for the simulation settings."""
+
+ simulationPrecision: int
+ centerFrequency: float
+ isSteadySimulation: bool
+ materialProperties: MaterialProperties
+
+
+class DefaultSettings(BaseModel):
+ """Pydantic model with the default parameters to run a simulation."""
+
+ is2d: bool
+ scenarioSettings: ScenarioSettings
+ transducers: list[Transducer]
+ displaySettings: Optional[DisplaySettings]
+ target: Optional[Target]
+ simulationSettings: SimulationSettings
+
+ @classmethod
+ def from_scenario(
+ cls, scenario_id: str, scenario: Union[Type[Scenario2D], Type[Scenario3D]]
+ ) -> "DefaultSettings":
+ """Instantiate the settings from a built in scenario."""
+ is_2d = issubclass(scenario, Scenario2D)
+ center_frequency = scenario.center_frequency
+ assert isinstance(center_frequency, float)
+ material_properties = MaterialProperties.from_scenario(scenario)
+ simulation_settings = SimulationSettings(
+ simulationPrecision=6, # TODO: make this a parameter
+ centerFrequency=center_frequency,
+ isSteadySimulation=True, # default value
+ materialProperties=material_properties,
+ )
+ scenario_settings = ScenarioSettings(
+ scenarioId=scenario_id,
+ isPreBuilt=True,
+ )
+ if is_2d:
+ display_settings = None
+ else:
+ display_settings = DisplaySettings(
+ sliceAxis=Axis.from_ndk_axis(scenario.slice_axis),
+ slicePosition=scenario.slice_position,
+ )
+
+ scenario_target = scenario.target
+ assert isinstance(scenario_target, NDKTarget)
+ target = Target.from_ndk_target(scenario_target)
+
+ transducers = []
+ if hasattr(scenario, "sources") and scenario.sources is not None:
+ for source in scenario.sources:
+ settings_model = TRANSDUCER_SETTINGS[type(source)]
+ transducer_settings = settings_model.from_source(source)
+ transducers.append(transducer_settings)
+
+ return cls(
+ is2d=is_2d,
+ scenarioSettings=scenario_settings,
+ transducers=transducers,
+ target=target,
+ simulationSettings=simulation_settings,
+ displaySettings=display_settings,
+ )
diff --git a/src/web/messages/transducers.py b/src/web/messages/transducers.py
new file mode 100644
index 00000000..60b29874
--- /dev/null
+++ b/src/web/messages/transducers.py
@@ -0,0 +1,322 @@
+"""Pydantic models for the transducers and their settings."""
+import re
+from enum import Enum
+from typing import Dict, List, Literal, Optional, Tuple, Type, Union
+
+import numpy as np
+from pydantic import BaseModel, Field
+from typing_extensions import Annotated
+
+from neurotechdevkit.sources import (
+ FocusedSource2D,
+ FocusedSource3D,
+ PhasedArraySource2D,
+ PhasedArraySource3D,
+ PlanarSource2D,
+ PlanarSource3D,
+ PointSource2D,
+ PointSource3D,
+ Source,
+)
+
+
+def title_case(string: str) -> str:
+ """Convert a string to title case.
+
+ Example:
+ >>> title_case('helloWorld')
+ 'Hello World'
+
+ Args:
+ string: The string to convert to title case.
+
+ Returns:
+ The string in title case.
+ """
+ if string != "":
+ result = re.sub("([A-Z])", r" \1", string)
+ return result[:1].upper() + result[1:]
+ return ""
+
+
+class TransducerType(str, Enum):
+ """Transducer type enum for the type of transducer."""
+
+ pointSource = "pointSource"
+ phasedArraySource = "phasedArraySource"
+ focusedSource = "focusedSource"
+ planarSource = "planarSource"
+
+ @classmethod
+ def from_source(
+ cls,
+ source: Union[
+ PointSource2D,
+ PointSource3D,
+ PhasedArraySource2D,
+ PhasedArraySource3D,
+ FocusedSource2D,
+ FocusedSource3D,
+ PlanarSource2D,
+ PlanarSource3D,
+ ],
+ ):
+ """Instantiate the transducer type from a source."""
+ if isinstance(source, (PointSource2D, PointSource3D)):
+ return cls.pointSource
+ elif isinstance(source, (PhasedArraySource2D, PhasedArraySource3D)):
+ return cls.phasedArraySource
+ elif isinstance(source, (FocusedSource2D, FocusedSource3D)):
+ return cls.focusedSource
+ elif isinstance(source, (PlanarSource2D, PlanarSource3D)):
+ return cls.planarSource
+
+ @classmethod
+ def get_transducer_titles(cls) -> List[Tuple[str, str]]:
+ """Get the transducer types and titles.
+
+ Returns:
+ The list of transducer types and titles.
+ """
+ titles = []
+ for transducer_type in cls:
+ title = title_case(transducer_type.value)
+ titles.append((transducer_type.name, title))
+ return titles
+
+
+class _BaseSourceSettings(BaseModel):
+ @classmethod
+ def from_source(cls, source) -> BaseModel:
+ """Instantiate the source settings from a source."""
+ raise NotImplementedError
+
+
+class PointSourceSettings(_BaseSourceSettings):
+ """Settings for a point source transducer."""
+
+ transducerType: Literal[TransducerType.pointSource]
+ delay: float
+ position: List[float]
+
+ @classmethod
+ def from_source(
+ cls, source: Union[PointSource2D, PointSource3D]
+ ) -> "PointSourceSettings":
+ """Instantiate the source settings from a source."""
+ return cls(
+ transducerType=TransducerType.pointSource,
+ position=source._position,
+ delay=source._delay,
+ )
+
+ def to_ndk_source(self) -> Union[PointSource2D, PointSource3D]:
+ """Instantiate the NDK source from transducer settings."""
+ if len(self.position) == 2:
+ return PointSource2D(
+ delay=self.delay,
+ position=self.position,
+ )
+ else:
+ return PointSource3D(
+ delay=self.delay,
+ position=self.position,
+ )
+
+
+class PhasedArraySettings(_BaseSourceSettings):
+ """Settings for a phased array transducer."""
+
+ transducerType: Literal[TransducerType.phasedArraySource]
+ position: List[float]
+ direction: List[float]
+ numPoints: int
+ numElements: int
+ pitch: float
+ elementWidth: float
+ tiltAngle: float
+ focalLength: Optional[float]
+ delay: float
+ elementDelays: Optional[List[float]]
+ centerLine: Optional[List[float]]
+ height: Optional[float]
+
+ @classmethod
+ def from_source(
+ cls, source: Union[PhasedArraySource2D, PhasedArraySource3D]
+ ) -> "PhasedArraySettings":
+ """Instantiate the source settings from a source."""
+ if source._focal_length == np.inf:
+ focal_length = None
+ else:
+ focal_length = source._focal_length
+
+ element_delays = None
+ if isinstance(source._configured_element_delays, list):
+ element_delays = source._configured_element_delays
+ elif isinstance(source._configured_element_delays, np.ndarray):
+ element_delays = source._configured_element_delays.tolist()
+
+ return cls(
+ transducerType=TransducerType.phasedArraySource,
+ position=source._position,
+ direction=source._direction,
+ numPoints=source._num_points,
+ numElements=source._num_elements,
+ pitch=source._pitch,
+ elementWidth=source._element_width,
+ tiltAngle=source._tilt_angle,
+ focalLength=focal_length,
+ delay=source._delay,
+ elementDelays=element_delays,
+ centerLine=None,
+ height=None,
+ )
+
+ def to_ndk_source(self) -> Union[PhasedArraySource2D, PhasedArraySource3D]:
+ """Instantiate the NDK source from transducer settings."""
+ if len(self.position) == 2:
+ return PhasedArraySource2D(
+ position=self.position,
+ direction=self.direction,
+ num_points=self.numPoints,
+ num_elements=self.numElements,
+ pitch=self.pitch,
+ element_width=self.elementWidth,
+ tilt_angle=self.tiltAngle,
+ focal_length=self.focalLength or np.inf,
+ delay=self.delay,
+ element_delays=self.elementDelays,
+ )
+ else:
+ assert self.centerLine is not None
+ assert self.height is not None
+ return PhasedArraySource3D(
+ position=self.position,
+ direction=self.direction,
+ num_points=self.numPoints,
+ num_elements=self.numElements,
+ pitch=self.pitch,
+ element_width=self.elementWidth,
+ tilt_angle=self.tiltAngle,
+ focal_length=self.focalLength or np.inf,
+ delay=self.delay,
+ element_delays=self.elementDelays,
+ center_line=self.centerLine,
+ height=self.height,
+ )
+
+
+class FocusedSourceSettings(_BaseSourceSettings):
+ """Settings for a focused source transducer."""
+
+ transducerType: Literal[TransducerType.focusedSource]
+ position: List[float]
+ aperture: float
+ direction: List[float]
+ focalLength: float
+ numPoints: int
+ delay: float
+
+ @classmethod
+ def from_source(
+ cls, source: Union[FocusedSource2D, FocusedSource3D]
+ ) -> "FocusedSourceSettings":
+ """Instantiate the source settings from a source."""
+ return cls(
+ transducerType=TransducerType.focusedSource,
+ position=source._position,
+ direction=source._direction,
+ aperture=source._aperture,
+ focalLength=source._focal_length,
+ numPoints=source._num_points,
+ delay=source._delay,
+ )
+
+ def to_ndk_source(self) -> Union[FocusedSource2D, FocusedSource3D]:
+ """Instantiate the NDK source from transducer settings."""
+ if len(self.position) == 2:
+ return FocusedSource2D(
+ position=self.position,
+ direction=self.direction,
+ aperture=self.aperture,
+ focal_length=self.focalLength,
+ num_points=self.numPoints,
+ delay=self.delay,
+ )
+ else:
+ return FocusedSource3D(
+ position=self.position,
+ direction=self.direction,
+ aperture=self.aperture,
+ focal_length=self.focalLength,
+ num_points=self.numPoints,
+ delay=self.delay,
+ )
+
+
+class PlanarSourceSettings(_BaseSourceSettings):
+ """Settings for a planar source transducer."""
+
+ transducerType: Literal[TransducerType.planarSource]
+ aperture: float
+ delay: float
+ direction: List[float]
+ numPoints: int
+ position: List[float]
+
+ @classmethod
+ def from_source(
+ cls, source: Union[PlanarSource2D, PlanarSource3D]
+ ) -> "PlanarSourceSettings":
+ """Instantiate the source settings from a source."""
+ return cls(
+ transducerType=TransducerType.planarSource,
+ aperture=source._aperture,
+ delay=source._delay,
+ direction=source._direction,
+ numPoints=source._num_points,
+ position=source._position,
+ )
+
+ def to_ndk_source(self) -> Union[PlanarSource2D, PlanarSource3D]:
+ """Instantiate the NDK source from transducer settings."""
+ if len(self.position) == 2:
+ return PlanarSource2D(
+ aperture=self.aperture,
+ delay=self.delay,
+ direction=self.direction,
+ num_points=self.numPoints,
+ position=self.position,
+ )
+ else:
+ return PlanarSource3D(
+ aperture=self.aperture,
+ delay=self.delay,
+ direction=self.direction,
+ num_points=self.numPoints,
+ position=self.position,
+ )
+
+
+TRANSDUCER_SETTINGS: Dict[Type[Source], Type[_BaseSourceSettings]] = {
+ PointSource2D: PointSourceSettings,
+ PointSource3D: PointSourceSettings,
+ PhasedArraySource2D: PhasedArraySettings,
+ PhasedArraySource3D: PhasedArraySettings,
+ FocusedSource2D: FocusedSourceSettings,
+ FocusedSource3D: FocusedSourceSettings,
+ PlanarSource2D: PlanarSourceSettings,
+ PlanarSource3D: PlanarSourceSettings,
+}
+
+
+Transducer = Annotated[
+ Union[
+ PointSourceSettings,
+ PhasedArraySettings,
+ FocusedSourceSettings,
+ PlanarSourceSettings,
+ ],
+ Field(discriminator="transducerType"),
+]
diff --git a/src/web/simulation_runner.py b/src/web/simulation_runner.py
new file mode 100644
index 00000000..72d0b658
--- /dev/null
+++ b/src/web/simulation_runner.py
@@ -0,0 +1,170 @@
+"""SimulationRunner class, which is a singleton that manages the simulation process."""
+import asyncio
+import ctypes
+from queue import Queue
+from threading import Thread
+from typing import Awaitable, Optional, Tuple
+
+
+def terminate_thread(thread: Thread):
+ """Terminates a python thread from another thread.
+
+ Args:
+ thread: The thread to terminate.
+ """
+ assert thread.ident is not None, "thread ID must be defined"
+ exc = ctypes.py_object(SystemExit)
+ res = ctypes.pythonapi.PyThreadState_SetAsyncExc(ctypes.c_long(thread.ident), exc)
+ if res == 0:
+ return
+ elif res > 1:
+ ctypes.pythonapi.PyThreadState_SetAsyncExc(thread.ident, None)
+ raise SystemError("PyThreadState_SetAsyncExc failed")
+
+
+class Response:
+ """Base class for responses."""
+
+ type: str
+
+
+class SimulationResponse(Response):
+ """Response containing the result of the simulation."""
+
+ type = "simulation"
+ data: Tuple[str, str]
+
+ def __init__(self, data: Tuple[str, str]):
+ """Initialize the response.
+
+ Args:
+ data: The result of the simulation.
+ """
+ self.data = data
+
+
+class SimulationError(Response):
+ """Response indicating that an error occurred during the simulation."""
+
+ type = "simulation_error"
+ error: Exception
+
+ def __init__(self, error: Exception):
+ """Initialize the response.
+
+ Args:
+ error: The error that occurred during the simulation.
+ """
+ self.error = error
+
+
+class NoSimulationResponse(Response):
+ """Response indicating that the simulation has not been run."""
+
+ type = "no_simulation"
+
+
+class SimulationRunner(object):
+ """Runs the simulation process and stores the result."""
+
+ _running: bool
+ _last_result: Response
+ _requests_queue: Queue
+ _configuration: dict
+
+ def __new__(cls):
+ """Singleton implementation."""
+ if not hasattr(cls, "instance"):
+ cls.instance = super(SimulationRunner, cls).__new__(cls)
+ return cls.instance
+
+ def get(self) -> Response:
+ """Get the stored result or wait for the simulation to finish."""
+ if self.has_last_result:
+ return self._last_result
+
+ if self._running:
+ callback_queue: Queue[Response] = Queue(1)
+ self._requests_queue.put(callback_queue)
+ return callback_queue.get()
+ return NoSimulationResponse()
+
+ def _run_in_loop(self, loop, executor, result):
+ asyncio.set_event_loop(loop)
+ result.append(loop.run_until_complete(executor))
+
+ def run(self, executor: Awaitable, configuration: dict) -> Response:
+ """Run the simulation process and store the result.
+
+ Args:
+ executor: The coroutine to run.
+ configuration: The configuration of the simulation.
+
+ Returns:
+ The result of the simulation.
+ """
+ self._running = True
+ self._configuration = configuration
+ communication_pipe: list[Tuple[str, str]] = []
+ self._thread = Thread(
+ target=self._run_in_loop, args=(self._loop, executor, communication_pipe)
+ )
+ self._thread.start()
+ self._thread.join()
+ self._running = False
+ result: Response
+ if len(communication_pipe) > 0:
+ response = communication_pipe.pop()
+ if isinstance(response, Exception):
+ result = SimulationError(response)
+ else:
+ result = SimulationResponse(response)
+ else:
+ result = NoSimulationResponse()
+ self._last_result = result
+
+ while not self._requests_queue.empty():
+ callback = self._requests_queue.get()
+ callback.put(result)
+ callback.task_done()
+ return result
+
+ @property
+ def is_running(self) -> bool:
+ """Whether the simulation is running."""
+ return self._running
+
+ @property
+ def has_last_result(self) -> bool:
+ """Whether the simulation has a result."""
+ return isinstance(self._last_result, SimulationResponse)
+
+ @property
+ def configuration(self) -> Optional[dict]:
+ """The configuration of the simulation.
+
+ Returns:
+ The configuration of the simulation if it exists, None otherwise.
+ """
+ if self._configuration:
+ return self._configuration
+ return None
+
+ def initialize(self):
+ """Initialize the simulation runner."""
+ self._requests_queue = Queue()
+ self._last_result = None
+ self._thread = None
+ self._loop = asyncio.new_event_loop()
+ self._running = False
+ self._configuration = None
+
+ def reset(self):
+ """Reset the simulation runner."""
+ if self._thread:
+ terminate_thread(self._thread)
+ self._thread = None
+ self._loop = asyncio.new_event_loop()
+ self._running = False
+ self._configuration = None
+ self._last_result = NoSimulationResponse()
diff --git a/src/web/views.py b/src/web/views.py
new file mode 100644
index 00000000..0d5b4f42
--- /dev/null
+++ b/src/web/views.py
@@ -0,0 +1,149 @@
+"""Views for the web app."""
+
+import os
+import shutil
+import tempfile
+from pathlib import Path
+
+from flask import Blueprint, current_app, jsonify, request, send_from_directory
+from pydantic import ValidationError
+from web.computed_tomography import get_available_cts, validate_ct
+from web.controller import (
+ get_built_in_scenarios,
+ get_default_material_properties,
+ get_scenario_layout,
+ get_simulation_image,
+)
+from web.messages.material_properties import MaterialName
+from web.messages.requests import RenderLayoutRequest, SimulateRequest
+from web.messages.transducers import TransducerType
+from web.simulation_runner import SimulationRunner
+from werkzeug.utils import secure_filename
+
+bp = Blueprint("main", __name__, url_prefix="/")
+
+DEFAULT_CENTER_FREQUENCY = 5e5
+
+
+@bp.route("/", defaults={"path": ""})
+@bp.route("/
+
+
+