attempt animation

.ipynb_checkpoints/app-checkpoint.py

@@ -0,0 +1,570 @@
+import gradio as gr
+import os
+import matplotlib.pyplot as plt
+from scipy.integrate import odeint
+import torch
+from torch.utils import data
+from torch.utils.data import DataLoader, Dataset
+from torch import nn, optim
+from skimage.transform import rescale, resize
+from torch import nn, optim
+import torch.nn.functional as F
+from torch.utils.data import Subset
+from scipy.interpolate import interp1d
+import collections
+import numpy as np
+import random
+
+#for pvloop simulator:
+import pandas as pd
+from scipy.integrate import odeint 
+import torchvision
+import echonet
+import matplotlib.animation as animation
+
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+sequences_all = []
+info_data_all = []
+path = 'EchoNet-Dynamic'
+output_path = ''
+
+class Echo(torchvision.datasets.VisionDataset):
+    """EchoNet-Dynamic Dataset.
+    Args:
+        root (string): Root directory of dataset (defaults to `echonet.config.DATA_DIR`)
+        split (string): One of {``train'', ``val'', ``test'', ``all'', or ``external_test''}
+        target_type (string or list, optional): Type of target to use,
+            ``Filename'', ``EF'', ``EDV'', ``ESV'', ``LargeIndex'',
+            ``SmallIndex'', ``LargeFrame'', ``SmallFrame'', ``LargeTrace'',
+            or ``SmallTrace''
+            Can also be a list to output a tuple with all specified target types.
+            The targets represent:
+                ``Filename'' (string): filename of video
+                ``EF'' (float): ejection fraction
+                ``EDV'' (float): end-diastolic volume
+                ``ESV'' (float): end-systolic volume
+                ``LargeIndex'' (int): index of large (diastolic) frame in video
+                ``SmallIndex'' (int): index of small (systolic) frame in video
+                ``LargeFrame'' (np.array shape=(3, height, width)): normalized large (diastolic) frame
+                ``SmallFrame'' (np.array shape=(3, height, width)): normalized small (systolic) frame
+                ``LargeTrace'' (np.array shape=(height, width)): left ventricle large (diastolic) segmentation
+                    value of 0 indicates pixel is outside left ventricle
+                             1 indicates pixel is inside left ventricle
+                ``SmallTrace'' (np.array shape=(height, width)): left ventricle small (systolic) segmentation
+                    value of 0 indicates pixel is outside left ventricle
+                             1 indicates pixel is inside left ventricle
+            Defaults to ``EF''.
+        mean (int, float, or np.array shape=(3,), optional): means for all (if scalar) or each (if np.array) channel.
+            Used for normalizing the video. Defaults to 0 (video is not shifted).
+        std (int, float, or np.array shape=(3,), optional): standard deviation for all (if scalar) or each (if np.array) channel.
+            Used for normalizing the video. Defaults to 0 (video is not scaled).
+        length (int or None, optional): Number of frames to clip from video. If ``None'', longest possible clip is returned.
+            Defaults to 16.
+        period (int, optional): Sampling period for taking a clip from the video (i.e. every ``period''-th frame is taken)
+            Defaults to 2.
+        max_length (int or None, optional): Maximum number of frames to clip from video (main use is for shortening excessively
+            long videos when ``length'' is set to None). If ``None'', shortening is not applied to any video.
+            Defaults to 250.
+        clips (int, optional): Number of clips to sample. Main use is for test-time augmentation with random clips.
+            Defaults to 1.
+        pad (int or None, optional): Number of pixels to pad all frames on each side (used as augmentation).
+            and a window of the original size is taken. If ``None'', no padding occurs.
+            Defaults to ``None''.
+        noise (float or None, optional): Fraction of pixels to black out as simulated noise. If ``None'', no simulated noise is added.
+            Defaults to ``None''.
+        target_transform (callable, optional): A function/transform that takes in the target and transforms it.
+        external_test_location (string): Path to videos to use for external testing.
+    """
+
+    def __init__(self, root=None,
+                 split="train", target_type="EF",
+                 mean=0., std=1.,
+                 length=16, period=2,
+                 max_length=250,
+                 clips=1,
+                 pad=None,
+                 noise=None,
+                 target_transform=None,
+                 external_test_location=None):
+        if root is None:
+            root = path
+
+        super().__init__(root, target_transform=target_transform)
+
+        self.split = split.upper()
+        if not isinstance(target_type, list):
+            target_type = [target_type]
+        self.target_type = target_type
+        self.mean = mean
+        self.std = std
+        self.length = length
+        self.max_length = max_length
+        self.period = period
+        self.clips = clips
+        self.pad = pad
+        self.noise = noise
+        self.target_transform = target_transform
+        self.external_test_location = external_test_location
+
+        self.fnames, self.outcome = [], []
+
+        if self.split == "EXTERNAL_TEST":
+            self.fnames = sorted(os.listdir(self.external_test_location))
+        else:
+            # Load video-level labels
+            with open(f"{self.root}/FileList.csv") as f:
+                data = pd.read_csv(f)
+            data["Split"].map(lambda x: x.upper())
+
+            if self.split != "ALL":
+                data = data[data["Split"] == self.split]
+
+            self.header = data.columns.tolist()
+            self.fnames = data["FileName"].tolist()
+            self.fnames = [fn + ".avi" for fn in self.fnames if os.path.splitext(fn)[1] == ""]  # Assume avi if no suffix
+            self.outcome = data.values.tolist()
+
+            # Check that files are present
+            """
+            missing = set(self.fnames) - set(os.listdir(os.path.join(self.root, "Videos")))
+            if len(missing) != 0:
+                print("{} videos could not be found in {}:".format(len(missing), os.path.join(self.root, "Videos")))
+                for f in sorted(missing):
+                    print("\t", f)
+                raise FileNotFoundError(os.path.join(self.root, "Videos", sorted(missing)[0]))
+            """
+
+            # Load traces
+            self.frames = collections.defaultdict(list)
+            self.trace = collections.defaultdict(_defaultdict_of_lists)
+
+            with open(f"{self.root}/VolumeTracings.csv") as f:
+                header = f.readline().strip().split(",")
+                assert header == ["FileName", "X1", "Y1", "X2", "Y2", "Frame"]
+
+                for line in f:
+                    filename, x1, y1, x2, y2, frame = line.strip().split(',')
+                    x1 = float(x1)
+                    y1 = float(y1)
+                    x2 = float(x2)
+                    y2 = float(y2)
+                    frame = int(frame)
+                    if frame not in self.trace[filename]:
+                        self.frames[filename].append(frame)
+                    self.trace[filename][frame].append((x1, y1, x2, y2))
+            for filename in self.frames:
+                for frame in self.frames[filename]:
+                    self.trace[filename][frame] = np.array(self.trace[filename][frame])
+
+            # A small number of videos are missing traces; remove these videos
+            keep = [len(self.frames[f]) >= 2 for f in self.fnames]
+            self.fnames = [f for (f, k) in zip(self.fnames, keep) if k]
+            self.outcome = [f for (f, k) in zip(self.outcome, keep) if k]
+
+    def __getitem__(self, index):
+        # Find filename of video
+        if self.split == "EXTERNAL_TEST":
+            video = os.path.join(self.external_test_location, self.fnames[index])
+        elif self.split == "CLINICAL_TEST":
+            video = os.path.join(self.root, "ProcessedStrainStudyA4c", self.fnames[index])
+        else:
+            video = os.path.join(self.root, "Videos", self.fnames[index])
+
+        # Load video into np.array
+        video = echonet.utils.loadvideo(video).astype(np.float32)
+
+        # Add simulated noise (black out random pixels)
+        # 0 represents black at this point (video has not been normalized yet)
+        if self.noise is not None:
+            n = video.shape[1] * video.shape[2] * video.shape[3]
+            ind = np.random.choice(n, round(self.noise * n), replace=False)
+            f = ind % video.shape[1]
+            ind //= video.shape[1]
+            i = ind % video.shape[2]
+            ind //= video.shape[2]
+            j = ind
+            video[:, f, i, j] = 0
+
+        # Apply normalization
+        if isinstance(self.mean, (float, int)):
+            video -= self.mean
+        else:
+            video -= self.mean.reshape(3, 1, 1, 1)
+
+        if isinstance(self.std, (float, int)):
+            video /= self.std
+        else:
+            video /= self.std.reshape(3, 1, 1, 1)
+
+        # Set number of frames
+        c, f, h, w = video.shape
+        if self.length is None:
+            # Take as many frames as possible
+            length = f // self.period
+        else:
+            # Take specified number of frames
+            length = self.length
+
+        if self.max_length is not None:
+            # Shorten videos to max_length
+            length = min(length, self.max_length)
+
+        if f < length * self.period:
+            # Pad video with frames filled with zeros if too short
+            # 0 represents the mean color (dark grey), since this is after normalization
+            video = np.concatenate((video, np.zeros((c, length * self.period - f, h, w), video.dtype)), axis=1)
+            c, f, h, w = video.shape  # pylint: disable=E0633
+
+        if self.clips == "all":
+            # Take all possible clips of desired length
+            start = np.arange(f - (length - 1) * self.period)
+        else:
+            # Take random clips from video
+            start = np.random.choice(f - (length - 1) * self.period, self.clips)
+
+        # Gather targets
+        target = []
+        for t in self.target_type:
+            key = self.fnames[index]
+            if t == "Filename":
+                target.append(self.fnames[index])
+            elif t == "LargeIndex":
+                # Traces are sorted by cross-sectional area
+                # Largest (diastolic) frame is last
+                target.append(int(self.frames[key][-1]))
+            elif t == "SmallIndex":
+                # Largest (diastolic) frame is first
+                target.append(int(self.frames[key][0]))
+            elif t == "LargeFrame":
+                target.append(video[:, self.frames[key][-1], :, :])
+            elif t == "SmallFrame":
+                target.append(video[:, self.frames[key][0], :, :])
+            elif t in ["LargeTrace", "SmallTrace"]:
+                if t == "LargeTrace":
+                    t = self.trace[key][self.frames[key][-1]]
+                else:
+                    t = self.trace[key][self.frames[key][0]]
+                x1, y1, x2, y2 = t[:, 0], t[:, 1], t[:, 2], t[:, 3]
+                x = np.concatenate((x1[1:], np.flip(x2[1:])))
+                y = np.concatenate((y1[1:], np.flip(y2[1:])))
+
+                r, c = skimage.draw.polygon(np.rint(y).astype(np.int), np.rint(x).astype(np.int), (video.shape[2], video.shape[3]))
+                mask = np.zeros((video.shape[2], video.shape[3]), np.float32)
+                mask[r, c] = 1
+                target.append(mask)
+            else:
+                if self.split == "CLINICAL_TEST" or self.split == "EXTERNAL_TEST":
+                    target.append(np.float32(0))
+                else:
+                    target.append(np.float32(self.outcome[index][self.header.index(t)]))
+
+        if target != []:
+            target = tuple(target) if len(target) > 1 else target[0]
+            if self.target_transform is not None:
+                target = self.target_transform(target)
+
+        # Select clips from video
+        video = tuple(video[:, s + self.period * np.arange(length), :, :] for s in start)
+        if self.clips == 1:
+            video = video[0]
+        else:
+            video = np.stack(video)
+
+        if self.pad is not None:
+            # Add padding of zeros (mean color of videos)
+            # Crop of original size is taken out
+            # (Used as augmentation)
+            c, l, h, w = video.shape
+            temp = np.zeros((c, l, h + 2 * self.pad, w + 2 * self.pad), dtype=video.dtype)
+            temp[:, :, self.pad:-self.pad, self.pad:-self.pad] = video  # pylint: disable=E1130
+            i, j = np.random.randint(0, 2 * self.pad, 2)
+            video = temp[:, :, i:(i + h), j:(j + w)]
+
+        return video, target
+
+    def __len__(self):
+        return len(self.fnames)
+
+    def extra_repr(self) -> str:
+        """Additional information to add at end of __repr__."""
+        lines = ["Target type: {target_type}", "Split: {split}"]
+        return '\n'.join(lines).format(**self.__dict__)
+
+
+def _defaultdict_of_lists():
+    """Returns a defaultdict of lists.
+    This is used to avoid issues with Windows (if this function is anonymous,
+    the Echo dataset cannot be used in a dataloader).
+    """
+
+    return collections.defaultdict(list)
+## 
+print("Done loading training data!")
+# define normalization layer to make sure output xi in an interval [ai, bi]:
+# define normalization layer to make sure output xi in an interval [ai, bi]:
+
+
+class IntervalNormalizationLayer(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        # new_output = [Tc, start_p, Emax, Emin, Rm, Ra, Vd]
+        self.a = torch.tensor([0.4, 0., 0.5, 0.02, 0.005, 0.0001, 4.], dtype=torch.float32) #HR in 20-200->Tc in [0.3, 4]
+        self.b = torch.tensor([1.7, 280., 3.5, 0.1, 0.1, 0.25, 16.], dtype=torch.float32)
+        #taken out (initial conditions): a: 20, 5, 50; b: 400, 20, 100
+    def forward(self, inputs):
+        sigmoid_output = torch.sigmoid(inputs)
+        scaled_output = sigmoid_output * (self.b - self.a) + self.a
+        return scaled_output
+
+class NEW3DCNN(nn.Module):
+    def __init__(self, num_parameters):
+        super(NEW3DCNN, self).__init__()
+        
+        self.conv1      = nn.Conv3d(3, 8, kernel_size=3, padding=1)
+        self.batchnorm1 = nn.BatchNorm3d(8)
+        self.conv2      = nn.Conv3d(8, 16, kernel_size=3, padding=1)
+        self.batchnorm2 = nn.BatchNorm3d(16)
+        self.conv3      = nn.Conv3d(16, 32, kernel_size=3, padding=1)
+        self.batchnorm3 = nn.BatchNorm3d(32)
+        self.conv4      = nn.Conv3d(32, 64, kernel_size=3, padding=1)
+        self.batchnorm4 = nn.BatchNorm3d(64)
+        self.conv5      = nn.Conv3d(64, 128, kernel_size=3, padding=1)
+        self.batchnorm5 = nn.BatchNorm3d(128)
+        self.pool       = nn.AdaptiveAvgPool3d(1)
+        self.fc1        = nn.Linear(128, 512)
+        self.fc2        = nn.Linear(512, num_parameters)
+        self.norm1      = IntervalNormalizationLayer()
+        
+    def forward(self, x):
+        x = F.relu(self.batchnorm1(self.conv1(x)))
+        x = F.max_pool3d(x, kernel_size=2, stride=2)
+        x = F.relu(self.batchnorm2(self.conv2(x)))
+        x = F.max_pool3d(x, kernel_size=2, stride=2)
+        x = F.relu(self.batchnorm3(self.conv3(x)))
+        x = F.max_pool3d(x, kernel_size=2, stride=2)
+        x = F.relu(self.batchnorm4(self.conv4(x)))
+        x = F.max_pool3d(x, kernel_size=2, stride=2)
+        x = F.relu(self.batchnorm5(self.conv5(x)))
+        x = self.pool(x)
+        x = x.view(x.size(0), -1)
+        x = F.relu(self.fc1(x))
+        x = self.fc2(x)
+        x = self.norm1(x)
+
+        return x
+
+
+# Define a neural network with one hidden layer
+class Interpolator(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.fc1 = nn.Linear(6, 250).double()
+        self.fc2 = nn.Linear(250, 2).double()
+
+    def forward(self, x):
+        x = torch.relu(self.fc1(x))
+        x = self.fc2(x)
+        return x
+
+# Initialize the neural network
+net = Interpolator()
+net.load_state_dict(torch.load('final_model_weights/interp6_7param_weight.pt'))
+print("Done loading interpolator!")
+
+weights_path = 'final_model_weights/202_full_echonet_7param_Vloss_epoch_200_lr_0.001_weight_best_model.pt'
+model = NEW3DCNN(num_parameters = 7)
+model.load_state_dict(torch.load(weights_path))
+model.to(device)
+
+## PV loops
+
+#returns Plv at time t using Elastance(t) and Vlv(t)-Vd=x1
+def Plv(volume, Emax, Emin, t, Tc, Vd):
+    return Elastance(Emax,Emin,t, Tc)*(volume - Vd)
+
+#returns Elastance(t)
+def Elastance(Emax,Emin, t, Tc):
+    t = t-int(t/Tc)*Tc #can remove this if only want 1st ED (and the 1st ES before)
+    tn = t/(0.2+0.15*Tc)
+    return (Emax-Emin)*1.55*(tn/0.7)**1.9/((tn/0.7)**1.9+1)*1/((tn/1.17)**21.9+1) + Emin
+
+def solve_ODE_for_volume(Rm, Ra, Emax, Emin, Vd, Tc, start_v, t):
+    
+    # the ODE from Simaan et al 2008
+    def heart_ode(y, t, Rs, Rm, Ra, Rc, Ca, Cs, Cr, Ls, Emax, Emin, Tc):
+        x1, x2, x3, x4, x5 = y #here y is a vector of 5 values (not functions), at time t, used for getting (dy/dt)(t)
+        P_lv = Plv(x1+Vd,Emax,Emin,t,Tc,Vd)
+        dydt = [r(x2-P_lv)/Rm-r(P_lv-x4)/Ra, (x3-x2)/(Rs*Cr)-r(x2-P_lv)/(Cr*Rm), (x2-x3)/(Rs*Cs)+x5/Cs, -x5/Ca+r(P_lv-x4)/(Ca*Ra), (x4-x3-Rc*x5)/Ls]
+        return dydt
+
+    # RELU for diodes
+    def r(u):
+        return max(u, 0.)
+    
+    # Define fixed parameters
+    Rs = 1.0
+    Rc = 0.0398
+    Ca = 0.08
+    Cs = 1.33
+    Cr = 4.400
+    Ls = 0.0005
+    startp = 75.
+
+    # Initial conditions
+    start_pla = float(start_v*Elastance(Emax, Emin, 0, Tc))
+    start_pao = startp
+    start_pa = start_pao
+    start_qt = 0 #aortic flow is Q_T and is 0 at ED, also see Fig5 in simaan2008dynamical
+    y0 = [start_v, start_pla, start_pa, start_pao, start_qt]
+
+    # Solve
+    sol = odeint(heart_ode, y0, t, args = (Rs, Rm, Ra, Rc, Ca, Cs, Cr, Ls, Emax, Emin, Tc)) #t: list of values
+
+    # volume is the first state variable plus theoretical zero pressure volume
+    volumes = np.array(sol[:, 0]) + Vd
+    
+    return volumes
+
+def pvloop_simulator(Rm, Ra, Emax, Emin, Vd, Tc, start_v):
+    
+
+    # Define initial parameters
+    init_Emax = Emax # 3.0 # .5 to 3.5
+    init_Emin = Emin # 0.04 # .02 to .1
+    # init_Tc = Tc # .4 # .4 to 1.7
+    init_Vd = Vd # 10.0 # 0 to 25
+    
+    # DUMMY VOLUME
+    # def volume(t, Tc):
+        # return 50*np.sin(2 * np.pi * t*(1/Tc))+100
+    
+    # SOLVE the ODE model for the VOLUME CURVE
+    N = 100
+    t =  np.linspace(0, Tc*N, int(60000*N)) #np.linspace(1, 100, 1000000)
+    volumes = solve_ODE_for_volume(Rm, Ra, Emax, Emin, Vd, Tc, start_v, t)
+    
+    # FUNCTIONS for PRESSURE CURVE
+    vectorized_Elastance = np.vectorize(Elastance)
+    vectorized_Plv = np.vectorize(Plv)
+
+    def pressure(t, volume, Emax, Emin, Tc, Vd):
+        return vectorized_Plv(volume, Emax, Emin, t, Tc, Vd)
+
+    # calculate PRESSURE
+    pressures = pressure(t, volumes, init_Emax, init_Emin, Tc, init_Vd)
+    
+    # Create the figure and the loop that we will manipulate
+    fig, ax = plt.subplots()
+    plt.ylim((0,220))
+    plt.xlim((0,250))
+    line = ax.plot(volumes[(N-2)*60000], pressures[(N-2)*60000], lw=1)
+    #line = ax.plot(volumes[(N-2)*60000:(N)*60000], pressures[(N-2)*60000:(N)*60000], lw=1)
+    #print(line)
+    line = line[0]
+    #print(line)
+    
+    fig.suptitle('Predicted PI-SSL LV Pressure Volume Loop', fontsize=16)
+    #plt.rcParams['fig.suptitle'] = -2.0
+    #ax.set_title(f'Mitral valve circuit resistance (Rm): {Rm} mmHg*s/ml \n Aortic valve circuit resistance (Ra): {Ra} mmHg*s/ml', fontsize=6)
+    ax.set_xlabel('LV Volume (ml)')
+    ax.set_ylabel('LV Pressure (mmHg)')
+
+    # adjust the main plot to make room for the sliders
+    # fig.subplots_adjust(left=0.25, bottom=0.25)
+
+    def update(frame):
+        # for each frame, update the data stored on each artist.
+        x = volumes[:(N-2)*60000+frame]
+        y = pressures[:(N-2)*60000:(N)+frame]
+        line.set_xdata(x)
+        line.set_ydata(y)
+        return line
+
+    anim = animation.FuncAnimation(fig=fig, func=update, frames=40, interval=30)
+    
+    return plt, Rm, Ra, Emax, Emin, Vd, Tc, start_v
+
+def pvloop_simulator_plot_only(Rm, Ra, Emax, Emin, Vd, Tc, start_v):
+    plot,_,_,_,_,_,_,_ =pvloop_simulator(Rm, Ra, Emax, Emin, Vd, Tc, start_v)
+    return plot
+
+## Demo 
+
+def generate_example():
+        # get random input
+        data_path = 'EchoNet-Dynamic'
+        image_data = Echo(root = data_path, split = 'all', target_type=['Filename','LargeIndex','SmallIndex'])
+        image_loaded_data = DataLoader(image_data, batch_size=30, shuffle=True)
+        val_data = next(iter(image_loaded_data))
+        #create_echo_clip(val_data,'test')
+        val_seq = val_data[0]
+    
+        val_tensor = torch.tensor(val_seq, dtype=torch.float32) 
+        n=random.randint(0, 29)
+        results = model(val_tensor)[n]
+
+        filename = val_data[1][0][n]
+        video = f"EchoNet-Dynamic/Videos/{filename}"
+
+        plot, Rm, Ra, Emax, Emin, Vd,Tc, start_v = pvloop_simulator(Rm=round(results[4].item(),2), Ra=round(results[5].item(),2), Emax=results[2].item(), Emin=round(results[3].item(),2), Vd=round(results[6].item(),2), Tc=round(results[0].item(),2), start_v=round(results[1].item(),2))
+        video = video.replace("avi", "mp4")
+        return video, plot, Rm, Ra, Emax, Emin, Vd, Tc, start_v
+
+title = "Physics-informed self-supervised learning for predicting cardiac digital twins with echocardiography"
+
+description = """
+<p style='text-align: center'> Keying Kuang, Frances Dean, Jack B. Jedlicki, David Ouyang, Anthony Philippakis, David Sontag, Ahmed Alaa <br></p>
+<p> We develop methodology for predicting digital twins from non-invasive cardiac ultrasound images in <a href='https://arxiv.org/abs/2403.00177'>Non-Invasive Medical Digital Twins using Physics-Informed Self-Supervised Learning</a>. Check out our <a href='https://github.com/AlaaLab/CardioPINN' target='_blank'>code.</a> \n \n 
+We demonstrate the ability of our model to predict left ventricular pressure-volume loops using image data here. To run example predictions on samples from the <a href='https://echonet.github.io/dynamic/'>EchoNet</a> dataset, click the first button. \n \n 
+Below you can input values of predicted parameters and output a simulated pressure-volume loop predicted by the <a href='https://ieeexplore.ieee.org/document/4729737/keywords#keywords'>Simaan et al 2008</a> hydraulic analogy model by pressing 'Run simulation.'</p>
+"""
+
+gr.Markdown("<h1 style='text-align: center; margin-bottom: 1rem'>" + title + "</h1>")
+gr.Markdown(description)
+
+with gr.Blocks() as demo:
+        
+    # text
+    gr.Markdown("<h1 style='text-align: center; margin-bottom: 1rem'>" + title + "</h1>")
+    gr.Markdown(description)
+        
+    with gr.Row():
+        with gr.Column(scale=1.5, min_width=100):
+            
+            generate_button = gr.Button("Load sample echocardiogram and generate result")
+            with gr.Row():
+                video = gr.PlayableVideo() #format="avi"
+                plot = gr.Plot()
+            
+            with gr.Row():
+                Rm = gr.Number(label="Mitral valve circuit resistance (Rm) mmHg*s/ml:")
+                Ra = gr.Number(label="Aortic valve circuit resistance (Ra) mmHg*s/ml:")
+                Emax = gr.Number(label="Maximum elastance (Emax) mmHg/ml:")
+                Emin = gr.Number(label="Minimum elastance (Emin) mmHg/ml:")
+                Vd = gr.Number(label="Theoretical zero pressure volume (Vd) ml:")
+                Tc = gr.Number(label="Cycle duration (Tc) s:")
+                start_v = gr.Number(label="Initial volume (start_v) ml:")
+                
+            simulation_button = gr.Button("Run simulation")
+            
+            
+            
+            with gr.Row():
+                sl1 = gr.Slider(0.005, 0.1, value=Rm, label="Rm")
+                sl2 = gr.Slider(0.0001, 0.25, value=Ra, label="Ra")
+                sl3 = gr.Slider(0.5, 3.5, value=Emax, label="Emax")
+                sl4 = gr.Slider(0.02, 0.1, value= Emin, label="Emin")
+                sl5 = gr.Slider(4.0, 25.0, value=Vd, label="Vd")
+                sl6 = gr.Slider(0.4, 1.7, value=Tc, label="Tc") 
+                sl7 = gr.Slider(0.0, 280.0, value=start_v, label="start_v")
+    
+    
+    generate_button.click(fn=generate_example, outputs = [video,plot,Rm,Ra,Emax,Emin,Vd,Tc,start_v])
+    
+    
+    simulation_button.click(fn=pvloop_simulator_plot_only, inputs = [sl1,sl2,sl3,sl4,sl5,sl6,sl7], outputs = [gr.Plot()])
+    
+    
+    
+demo.launch()

EchoNet-Dynamic/FileList.csv

@@ -2,7 +2,6 @@ FileName,EF,ESV,EDV,FrameHeight,FrameWidth,FPS,NumberOfFrames,Split
 0X2CE2BBE899FB30A,69.3733509,15.07375645,49.21777894,112,112,50,208,TRAIN
 0X310589D4CDC13146,45.54886748,49.07256162,90.12220564,112,112,53,151,TRAIN
 0X34D6A77674B8E6F2,55.01383234,30.59875717,68.01814594,112,112,50,166,TRAIN
-0X352D7150FCBFA7C1,28.89583936,58.48777087,82.25646762,112,112,50,61,TRAIN
 0X36B33D2B6530F83E,57.65061751,33.64751654,79.45220108,112,112,50,161,VAL
 0X3B6528FD917A0E82,58.58439974,38.07170832,91.92600876,112,112,50,201,TRAIN
 0X49B360CA6BB04B97,57.87742067,25.5427545,60.63910355,112,112,50,155,TRAIN
@@ -11,7 +10,6 @@ FileName,EF,ESV,EDV,FrameHeight,FrameWidth,FPS,NumberOfFrames,Split
 0X55AEA1223ADFB9E8,58.42788325,51.81422337,124.636962,112,112,47,126,VAL
 0X5D98E2C64E1625FB,27.7459176,118.5770238,164.1111753,112,112,43,136,TRAIN
 0X623F4667A42B8338,60.35354935,30.37659467,76.61869895,112,112,50,127,VAL
-0X6382AE8EB4B73A3D,49.96284792,40.07870013,80.09788419,112,112,73,138,TRAIN
 0X63FECBA90BA79F81,64.86754791,21.00386139,59.78478627,112,112,50,198,VAL
 0X6532C54260D0231,55.73785825,29.72626047,67.15956186,112,112,50,140,TRAIN
 0X665E43AF6FE1563D,65.64105652,21.3883945,62.24986083,112,112,50,148,TRAIN

EchoNet-Dynamic/VolumeTracings.csv

@@ -125,48 +125,6 @@ FileName,X1,Y1,X2,Y2,Frame
 0X34D6A77674B8E6F2.avi,49.34517087,68.20596855,71.0245205,62.02791555,97
 0X34D6A77674B8E6F2.avi,49.63605055,70.06759853,71.56193286,63.8192901,97
 0X34D6A77674B8E6F2.avi,59.82206211,69.10937228,71.56568191,65.76274487,97
-0X352D7150FCBFA7C1.avi,49.80208333,13.70833333,66.75520833,54.90625,58
-0X352D7150FCBFA7C1.avi,49.9160378,14.90485525,51.40619797,14.29164775,58
-0X352D7150FCBFA7C1.avi,50.14394674,17.29789908,54.61442725,15.45827657,58
-0X352D7150FCBFA7C1.avi,50.37185567,19.69094292,57.82265652,16.6249054,58
-0X352D7150FCBFA7C1.avi,50.37217339,22.17764154,61.0308858,17.79153423,58
-0X352D7150FCBFA7C1.avi,49.84301648,24.88222133,64.23911507,18.95816306,58
-0X352D7150FCBFA7C1.avi,49.31385957,27.58680111,66.76347424,20.40620746,58
-0X352D7150FCBFA7C1.avi,48.92888294,30.23205006,68.60351955,22.13585004,58
-0X352D7150FCBFA7C1.avi,49.12000837,32.64023047,70.44356485,23.86549263,58
-0X352D7150FCBFA7C1.avi,49.3111338,35.04841088,72.28361015,25.59513521,58
-0X352D7150FCBFA7C1.avi,49.50225923,37.45659129,74.12365546,27.3247778,58
-0X352D7150FCBFA7C1.avi,49.69338466,39.8647717,75.41063515,29.28200933,58
-0X352D7150FCBFA7C1.avi,49.78129389,42.31542603,76.23844775,31.42819015,58
-0X352D7150FCBFA7C1.avi,49.73308878,44.82209202,77.06626035,33.57437097,58
-0X352D7150FCBFA7C1.avi,49.68488366,47.32875801,77.89407295,35.72055179,58
-0X352D7150FCBFA7C1.avi,49.63667855,49.83542399,78.72188556,37.86673261,58
-0X352D7150FCBFA7C1.avi,50.4411498,51.99120988,79.54969816,40.01291343,58
-0X352D7150FCBFA7C1.avi,51.70538648,53.95780026,79.65767974,42.4553079,58
-0X352D7150FCBFA7C1.avi,52.96962315,55.92439065,79.2872573,45.09456774,58
-0X352D7150FCBFA7C1.avi,54.23385983,57.89098103,78.91683487,47.73382758,58
-0X352D7150FCBFA7C1.avi,69.24867506,54.1991475,78.54641244,50.37308742,58
-0X352D7150FCBFA7C1.avi,52.171875,16.98958333,64.56770833,53.99479167,46
-0X352D7150FCBFA7C1.avi,51.86474412,18.1522931,54.03930391,17.42386913,46
-0X352D7150FCBFA7C1.avi,51.25048236,20.47771263,57.77416174,18.29244071,46
-0X352D7150FCBFA7C1.avi,50.63622059,22.80313216,60.71332962,19.42754884,46
-0X352D7150FCBFA7C1.avi,50.02195883,25.12855169,62.4651479,20.96038983,46
-0X352D7150FCBFA7C1.avi,49.58600989,27.39424081,64.21696618,22.49323082,46
-0X352D7150FCBFA7C1.avi,49.48817215,29.54667101,65.96878446,24.02607182,46
-0X352D7150FCBFA7C1.avi,49.39033441,31.69910121,67.72060274,25.55891281,46
-0X352D7150FCBFA7C1.avi,49.29249668,33.85153141,69.13705572,27.20409292,46
-0X352D7150FCBFA7C1.avi,49.25520833,35.98367906,70.06373992,29.0133335,46
-0X352D7150FCBFA7C1.avi,49.25520833,38.10333603,70.99042413,30.82257409,46
-0X352D7150FCBFA7C1.avi,49.25520833,40.222993,71.91710833,32.63181467,46
-0X352D7150FCBFA7C1.avi,49.25520833,42.34264996,72.81011857,34.45233521,46
-0X352D7150FCBFA7C1.avi,49.25520833,44.46230693,73.61454998,36.30252746,46
-0X352D7150FCBFA7C1.avi,49.25520833,46.5819639,74.4189814,38.15271972,46
-0X352D7150FCBFA7C1.avi,49.41717731,48.64736525,75.22341282,40.00291198,46
-0X352D7150FCBFA7C1.avi,50.0527613,50.55411724,76.02784423,41.85310424,46
-0X352D7150FCBFA7C1.avi,50.6883453,52.46086922,76.36473964,43.85990954,46
-0X352D7150FCBFA7C1.avi,51.32392929,54.36762121,76.54013569,45.92081315,46
-0X352D7150FCBFA7C1.avi,51.95951329,56.27437319,76.71553175,47.98171676,46
-0X352D7150FCBFA7C1.avi,66.33136696,53.57981317,76.8909278,50.04262037,46
 0X36B33D2B6530F83E.avi,47.61458333,12.796875,51.625,57.82291667,106
 0X36B33D2B6530F83E.avi,47.03179306,14.01795939,49.25192682,13.82021468,106
 0X36B33D2B6530F83E.avi,45.8662125,16.46012817,52.57323857,15.86274123,106
@@ -503,48 +461,6 @@ FileName,X1,Y1,X2,Y2,Frame
 0X623F4667A42B8338.avi,51.15840311,63.83187801,70.09225933,58.82733452,47
 0X623F4667A42B8338.avi,51.40727935,66.07176411,70.21849828,61.09963576,47
 0X623F4667A42B8338.avi,52.82458486,68.00281428,59.16708248,66.32638319,47
-0X6382AE8EB4B73A3D.avi,42.69270833,32.11979167,64.75,79.88020833,105
-0X6382AE8EB4B73A3D.avi,42.75418306,33.59518516,45.04089118,32.53911003,105
-0X6382AE8EB4B73A3D.avi,42.87704877,36.54601082,49.10540384,33.66955675,105
-0X6382AE8EB4B73A3D.avi,42.99516945,39.49902788,52.27247629,35.21447014,105
-0X6382AE8EB4B73A3D.avi,43.2041047,42.41010386,55.39453828,36.78017079,105
-0X6382AE8EB4B73A3D.avi,43.51378561,45.27465227,57.71668879,38.71529622,105
-0X6382AE8EB4B73A3D.avi,43.84747576,48.12811244,60.0388393,40.65042164,105
-0X6382AE8EB4B73A3D.avi,44.3580637,50.89987554,62.07196445,42.71902825,105
-0X6382AE8EB4B73A3D.avi,44.86865164,53.67163864,63.9801778,44.84532312,105
-0X6382AE8EB4B73A3D.avi,45.79554623,56.25113798,65.88839115,46.971618,105
-0X6382AE8EB4B73A3D.avi,46.97722542,58.71296963,67.57281822,49.20126455,105
-0X6382AE8EB4B73A3D.avi,48.15890461,61.17480127,68.85008614,51.61895026,105
-0X6382AE8EB4B73A3D.avi,49.3405838,63.63663292,70.12735406,54.03663596,105
-0X6382AE8EB4B73A3D.avi,49.98025454,66.34878144,71.40462198,56.45432167,105
-0X6382AE8EB4B73A3D.avi,50.57150052,69.08329407,72.59497827,58.91214595,105
-0X6382AE8EB4B73A3D.avi,50.84050148,71.96662979,73.62983127,61.44178663,105
-0X6382AE8EB4B73A3D.avi,50.7179345,75.03080412,74.66468428,63.97142732,105
-0X6382AE8EB4B73A3D.avi,50.97807563,77.91823159,75.55919254,66.56588371,105
-0X6382AE8EB4B73A3D.avi,52.01791822,80.44556792,75.84667268,69.44068514,105
-0X6382AE8EB4B73A3D.avi,55.49621283,81.84674894,75.95152344,72.39983068,105
-0X6382AE8EB4B73A3D.avi,67.64628257,79.24302617,75.59927352,75.57007996,105
-0X6382AE8EB4B73A3D.avi,49.61979167,33.03125,64.203125,76.96354167,90
-0X6382AE8EB4B73A3D.avi,49.48283763,34.30948768,50.85427487,33.8542388,90
-0X6382AE8EB4B73A3D.avi,49.20892955,36.86596305,53.32324129,35.50021641,90
-0X6382AE8EB4B73A3D.avi,49.14252472,39.35355766,55.35684419,37.29071303,90
-0X6382AE8EB4B73A3D.avi,49.28079067,41.77321178,56.96626433,39.2220172,90
-0X6382AE8EB4B73A3D.avi,49.41905662,44.19286589,58.57568448,41.15332137,90
-0X6382AE8EB4B73A3D.avi,49.57686062,46.60603434,60.18510462,43.08462554,90
-0X6382AE8EB4B73A3D.avi,49.73767197,49.0182045,61.54893279,45.09745402,90
-0X6382AE8EB4B73A3D.avi,49.89848331,51.43037466,62.70540985,47.17911274,90
-0X6382AE8EB4B73A3D.avi,50.01643199,53.8567731,63.86188692,49.26077146,90
-0X6382AE8EB4B73A3D.avi,50.08524073,56.29948354,65.01836399,51.34243018,90
-0X6382AE8EB4B73A3D.avi,50.15404948,58.74219398,66.04575691,53.46693841,90
-0X6382AE8EB4B73A3D.avi,50.22285822,61.18490443,66.98764672,55.61982941,90
-0X6382AE8EB4B73A3D.avi,50.29166697,63.62761487,67.92953653,57.77272041,90
-0X6382AE8EB4B73A3D.avi,50.36433888,66.06904294,68.87142635,59.92561141,90
-0X6382AE8EB4B73A3D.avi,50.45622753,68.504092,69.61306673,62.14497526,90
-0X6382AE8EB4B73A3D.avi,50.54811617,70.93914107,70.18222182,64.42159563,90
-0X6382AE8EB4B73A3D.avi,50.64000482,73.37419014,70.75137692,66.698216,90
-0X6382AE8EB4B73A3D.avi,51.00395115,75.7189296,71.17584133,69.02286647,90
-0X6382AE8EB4B73A3D.avi,52.45805061,77.7017925,71.52398717,71.3728509,90
-0X6382AE8EB4B73A3D.avi,57.28586759,78.56474918,71.19545567,73.94745853,90
 0X63FECBA90BA79F81.avi,57.16666667,28,66.03333333,95.66666667,151
 0X63FECBA90BA79F81.avi,52.8280287,30.354879,62.43932692,29.09546751,151
 0X63FECBA90BA79F81.avi,49.80404232,34.32386112,67.42054487,32.01549182,151

app.py

@@ -20,6 +20,7 @@ import pandas as pd
 from scipy.integrate import odeint 
 import torchvision
 import echonet
+import matplotlib.animation as animation
 
 device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
 
@@ -455,9 +456,10 @@ def pvloop_simulator(Rm, Ra, Emax, Emin, Vd, Tc, start_v):
     
     # Create the figure and the loop that we will manipulate
     fig, ax = plt.subplots()
-    plt.ylim((0,250))
-    plt.xlim((0,200))
-    line = ax.plot(volumes[(N-2)*60000:(N)*60000], pressures[(N-2)*60000:(N)*60000], lw=1)
+    plt.ylim((0,220))
+    plt.xlim((0,250))
+    line = ax.plot(volumes[(N-2)*60000], pressures[(N-2)*60000], lw=1)
+    #line = ax.plot(volumes[(N-2)*60000:(N)*60000], pressures[(N-2)*60000:(N)*60000], lw=1)
     #print(line)
     line = line[0]
     #print(line)
@@ -469,7 +471,17 @@ def pvloop_simulator(Rm, Ra, Emax, Emin, Vd, Tc, start_v):
     ax.set_ylabel('LV Pressure (mmHg)')
 
     # adjust the main plot to make room for the sliders
-    fig.subplots_adjust(left=0.25, bottom=0.25)
+    # fig.subplots_adjust(left=0.25, bottom=0.25)
+
+    def update(frame):
+        # for each frame, update the data stored on each artist.
+        x = volumes[:(N-2)*60000+frame]
+        y = pressures[:(N-2)*60000:(N)+frame]
+        line.set_xdata(x)
+        line.set_ydata(y)
+        return line
+
+    anim = animation.FuncAnimation(fig=fig, func=update, frames=40, interval=30)
     
     return plt, Rm, Ra, Emax, Emin, Vd, Tc, start_v