change directory name and run scripts to account for name change

visualization_interface/flask-server/server.py

@@ -0,0 +1,381 @@
+from flask import Flask
+from flask import request
+import pandas as pd
+import json
+import numpy as np
+from sklearn.decomposition import PCA
+import sys
+import process_input_data
+app = Flask(__name__)
+
+@app.route('/fetchIndividualFacialRawData', methods=["POST"])
+def fetchIndividualFacialRawData():
+    id = request.json['id']
+    if id:
+        individualFacialRawData = process_input_data.read_rawFacialDf(sys.argv[1], id)
+    else:
+        individualFacialRawData = process_input_data.read_rawFacialDf(sys.argv[1], inputData['Filename'][0])
+    if individualFacialRawData.empty:
+        return {}
+    return individualFacialRawData.fillna(0).to_json(orient="records")
+
+
+@app.route('/fetchIndividualMovementRawData', methods=["POST"])
+def fetchIndividualMovementRawData():
+    id = request.json['id']
+    if id:
+        individualMovementRawData  = process_input_data.read_rawMovementDf(sys.argv[1], id)
+    else:
+        individualMovementRawData  = process_input_data.read_rawMovementDf(sys.argv[1], inputData['Filename'][0])
+    if individualMovementRawData.empty:
+        return {}
+    return individualMovementRawData.fillna(0).to_json(orient="records")
+
+@app.route('/fetchIndividualAcousticRawData', methods=["POST"])
+def fetchIndividualAcousticRawData():
+    id = request.json['id']
+    if id:
+        individualAcousticRawData = process_input_data.read_rawAcousticDf(sys.argv[1], id)
+    else:
+        individualAcousticRawData = process_input_data.read_rawAcousticDf(sys.argv[1], inputData['Filename'][0])
+    if individualAcousticRawData.empty:
+        return {}
+    return individualAcousticRawData.fillna(0).to_json(orient="records")
+
+@app.route('/fetchIndividualDerivedData', methods=["POST"])
+def fetchIndividualDerivedData():
+    if len(list(inputData.columns)) <2:
+        return {}
+    id = request.json['id']
+    if id:
+        res = inputData.loc[inputData['Filename'] == id, ~inputData.columns.isin(['Filename'])]
+    else:  
+        res =  inputData.iloc[:1, :].loc[:, ~inputData.columns.isin(['Filename'])]
+    return res.fillna(0).to_json(orient="records")
+
+
+
+@app.route('/fetchIndividualFacialTimelineData', methods=["POST"])
+def fetchIndividualFacialTimelineData():
+    id = request.json['id']
+    timepoints = 20
+    if id:
+        dfFace = process_input_data.read_rawFacialDf(sys.argv[1], id)
+        dfMovement = process_input_data.read_rawMovementDf(sys.argv[1], id)
+        
+    else:
+        dfFace = process_input_data.read_rawFacialDf(sys.argv[1], inputData['Filename'][0])
+        dfMovement = process_input_data.read_rawMovementDf(sys.argv[1], inputData['Filename'][0])
+    if dfFace.empty:
+        return {}
+    dfFace=dfFace.fillna(0)
+    attrOfInterest= ["fac_angintsoft", "fac_feaintsoft", "fac_disintsoft", "fac_sadintsoft",
+                        "fac_conintsoft", "fac_surintsoft", "fac_hapintsoft", 
+                        "fac_AU01int", "fac_AU02int", "fac_AU04int", "fac_AU05int", "fac_AU06int", 
+                        "fac_AU07int", "fac_AU09int", "fac_AU10int", "fac_AU12int","fac_AU14int", 
+                        "fac_AU15int", "fac_AU17int", "fac_AU20int", "fac_AU23int", "fac_AU25int", 
+                        "fac_AU26int", "fac_asymmaskcom", "fac_asymmaskeye", "fac_asymmaskeyebrow",
+                        "fac_asymmaskmouth", "fac_paiintsoft", "fac_comintsoft", 
+                        "fac_comlowintsoft", "fac_comuppintsoft"]
+    timelineObject = {}
+    for a in attrOfInterest:
+        timelineObject[a] = []
+    seg = len(dfFace)//19
+    reminder = len(dfFace)%19
+
+    for t in range(0,timepoints):
+            for k in attrOfInterest:
+                if t <= reminder:
+                    timelineObject[k].append(sum(list(dfFace[t*(seg + 1):(t+1)*(seg+1)][k]))/(seg+1))
+                else:
+                    timelineObject[k].append(sum(list(dfFace[t*seg:(t+1)*seg][k]))/seg)
+    if dfMovement.empty:
+            return timelineObject
+    dfMovement=dfMovement.fillna(0)
+    movementAttr = ["mov_hposepitch", "mov_hposeyaw", "mov_hposeroll"]
+    for a in movementAttr:
+        timelineObject[a] = []
+    seg = len(dfMovement)//20
+    reminder = len(dfMovement)%20
+    for t in range(0,timepoints):
+            for k in movementAttr:
+                if t <= reminder:
+                    timelineObject[k].append(sum(list(dfMovement[t*(seg + 1):(t+1)*(seg+1)][k]))/(seg+1))
+                else:
+                    timelineObject[k].append(sum(list(dfMovement[t*seg:(t+1)*seg][k]))/seg)
+
+    return timelineObject
+
+
+@app.route('/getRawAttributesAndIds')
+def getRawAttributesAndIds():
+    result = {}
+    if not individualFacialRawData.empty:
+        result['facial'] = [x for x in list(individualFacialRawData.columns)]
+    else:
+        result['facial'] =[]
+    if not individualAcousticRawData.empty:
+        result['acoustic'] = [x for x in list(individualAcousticRawData.columns)]
+    else:
+        result['acoustic'] = []
+    if not individualMovementRawData.empty:
+        result['movement'] = [x for x in list(individualMovementRawData.columns)]
+    else:
+        result['movement'] = []
+    if len(rawDataArgs) > 0:
+        result['ids'] = rawDataArgs['ids']
+    else:
+        result['ids'] = []
+    return result
+
+def individualCorrMatrixData(id, corrArgs):
+    individualFacialRawData = pd.DataFrame()
+    individualMovementRawData = pd.DataFrame()
+    individualAcousticRawData = pd.DataFrame()
+    if id:
+        if len([x for x in corrArgs if "fac_" in x])>0:
+            individualFacialRawData = process_input_data.read_rawFacialDf(sys.argv[1], id)
+        if len([x for x in corrArgs if "mov_" in x])>0:
+            individualMovementRawData  = process_input_data.read_rawMovementDf(sys.argv[1], id)
+        if len([x for x in corrArgs if "aco_" in x])>0:
+            individualAcousticRawData = process_input_data.read_rawAcousticDf(sys.argv[1], id)
+    else:
+        if len([x for x in corrArgs if "fac_" in x])>0:
+            individualFacialRawData = process_input_data.read_rawFacialDf(sys.argv[1], inputData['Filename'][0])
+        if len([x for x in corrArgs if "mov_" in x])>0:
+            individualMovementRawData  = process_input_data.read_rawMovementDf(sys.argv[1], inputData['Filename'][0])
+        if len(list(filter(lambda x : "aco_" in x or "tremor_median" in x or "fac_features_mean" in x or "fac_corr" in x, individualMovementRawData))) >0:
+            individualAcousticRawData = process_input_data.read_rawAcousticDf(sys.argv[1], inputData['Filename'][0])
+    f = individualFacialRawData.loc[:, individualFacialRawData.columns.isin(corrArgs)]
+    m = individualMovementRawData.loc[:, individualMovementRawData.columns.isin(corrArgs)]
+    a = individualAcousticRawData.loc[:, individualAcousticRawData.columns.isin(corrArgs)]
+    if f.empty:
+        f = pd.DataFrame()
+    if m.empty:
+        m = pd.DataFrame()
+    if a.empty:
+        a = pd.DataFrame()
+    min_len = float('inf')
+    if not f.empty:
+        min_len = len(f)
+    if not m.empty:
+        min_len = min(min_len, len(m))
+    if not a.empty:
+        min_len=min(min_len, len(a))
+    if min_len == float('inf'):
+        min_len = 0
+
+    if min_len == len(f):
+        all_df = f.copy()
+        if len(f) == len(m):
+            for x in m.columns:
+                all_df[x] = m[x]
+        else:
+            seg = int(len(m)/(max(len(f),1)))
+            reminder = len(m)%(max(len(f),1))
+            for i, row in all_df.iterrows():
+                for x in m.columns:
+                    if i <reminder:
+                        all_df.loc[i,x] = sum(list(m[i*(seg + 1):(i+1)*(seg+1)][x]))/(seg+1)
+                    else:
+                        all_df.loc[i,x] = sum(list(m[i*seg:(i+1)*seg][x]))/seg
+        if len(a) > len(f):
+            seg = int(len(a)/(max(len(f),1)))
+            reminder = len(a)%(max(len(f),1)) 
+            for i, row in all_df.iterrows():
+                for x in a.columns:
+                    if i <reminder:
+                        all_df.loc[i,x] = sum(list(a[i*(seg + 1):(i+1)*(seg+1)][x]))/(seg+1)
+                    else:
+                        all_df.loc[i,x] = sum(list(a[i*seg:(i+1)*seg][x]))/seg
+        else:
+            for x in a.columns:
+                all_df[x] = a[x]    
+    elif len(m) == min_len:
+        all_df = m.copy()
+        seg = int(len(f)/(max(len(m),1)))
+        reminder = len(f)%(max(len(m),1))  
+        for i, row in all_df.iterrows():
+            for x in f.columns:
+                if i <reminder:
+                    all_df.loc[i,x] = sum(list(f[i*(seg + 1):(i+1)*(seg+1)][x]))/(seg+1)
+                else:
+                    all_df.loc[i,x] = sum(list(f[i*seg:(i+1)*seg][x]))/seg
+        if len(a) > len(m):
+            seg = int(len(a)/(max(len(m),1)))
+            reminder = len(a)%(max(len(m),1))   
+            for i, row in all_df.iterrows():
+                for x in a.columns:
+                    if i <reminder:
+                        all_df.loc[i,x] = sum(list(a[i*(seg + 1):(i+1)*(seg+1)][x]))/(seg+1)
+                    else:
+                        all_df.loc[i,x] = sum(list(a[i*seg:(i+1)*seg][x]))/seg
+        else:
+            for x in a.columns:
+                all_df[x] = a[x]
+    else:
+        all_df = a.copy()
+        seg = int(len(f)/(max(len(a),1)))
+        reminder = len(f)%(max(len(a),1))
+        for i, row in all_df.iterrows():
+            for x in f.columns:
+                if i <reminder:
+                    all_df.loc[i,x] = sum(list(f[i*(seg + 1):(i+1)*(seg+1)][x]))/(seg+1)
+                else:
+                    all_df.loc[i,x] = sum(list(f[i*seg:(i+1)*seg][x]))/seg
+        seg = int(len(m)/(max(len(a),1)))
+        reminder = len(m)%(max(len(a),1))
+        for i, row in all_df.iterrows():
+            for x in m.columns:
+                if i <reminder:
+                    all_df.loc[i,x] = sum(list(m[i*(seg + 1):(i+1)*(seg+1)][x]))/(seg+1)
+                else:
+                    all_df.loc[i,x] = sum(list(m[i*seg:(i+1)*seg][x]))/seg
+    return all_df.fillna(0)
+
+
+@app.route("/performPCA")
+def performPCA(PCAargs=[]):
+    if len(list(inputData.columns)) <2:
+        return {}
+    pca = PCA()
+    if len(PCAargs) == 0:
+        X = pd.DataFrame(columns = [x for x in list(inputData.columns) if x not in ['Filename']])
+        X = inputData.loc[:, ~inputData.columns.isin(['Filename'])]
+
+    else:
+        X = pd.DataFrame(columns = [x for x in PCAargs ])
+        X = inputData.loc[:, inputData.columns.isin(PCAargs)]
+
+    X = X.fillna(0)
+    x_pca = pca.fit_transform(X)
+    x_pca = pd.DataFrame(x_pca)
+    x_pca = x_pca.iloc[:, list(range(2))]
+    x_pca.columns = ['PC1', "PC2"]
+    pc1 = x_pca["PC1"].to_numpy()
+    pc2 = x_pca["PC2"].to_numpy()
+    pc1 = list((pc1 -pc1.mean())/np.std(pc1))
+    pc2 = list((pc2 -pc2.mean())/np.std(pc2))
+    pca_results =[[pc1[i], pc2[i]] for i in range(0, len(pc1))]
+
+    return dict(zip(inputData['Filename'], pca_results))
+
+
+@app.route('/updatePCA', methods=["POST"])
+def updatePCA():
+    PCAargs = request.json['PCA_args']
+    return performPCA(PCAargs)
+
+
+@app.route('/defaultDistribution', methods=["POST"])
+def defaultDistribution():
+    args = request.json['distributionArgs']
+    return {"data":updateDistribution(args)}
+
+
+@app.route('/updateDistribution', methods=["POST"])
+def updateDistribution(attr=[]):
+    if len(list(inputData.columns)) <2:
+        return {}
+    if len(attr) !=0:
+        distributionArgs = attr
+    else:
+        distributionArgs = request.json['distributionArgs']
+    if len(distributionArgs) == 0:
+        df = pd.DataFrame(columns = [x for x in list(inputData.columns) if x not in ['Filename']])
+        df = inputData.loc[:, ~inputData.columns.isin(['Filename'])]
+
+    else:
+        cols = ['Filename']+ distributionArgs
+        df = pd.DataFrame(columns = [c for c in list(cols )])
+        df = inputData.loc[:, inputData.columns.isin(cols)]
+    df = df.fillna(0)
+    if len(distributionArgs) ==0:
+        return {}
+    result = {}
+    for i, row in df.iterrows():
+        result[row['Filename']]={}
+        result[row['Filename']]['id'] = row['Filename']
+        for attr in distributionArgs:
+            result[row['Filename']][attr] = row[attr]
+
+    return result
+
+
+@app.route('/defaultCorrMatrix', methods=["POST"])
+def defaultCorrMatrix():
+    corrMatrixArgs = request.json['corrMatrix_args']
+    individual_corr = request.json['individual']
+    id= request.json['id']
+    return updateCorrMatrix(corrMatrixArgs, individual_corr, id)
+
+
+@app.route('/updateCorrMatrix', methods=["POST"])
+def updateCorrMatrix(attr=[], individual = False, id=None):
+    if len(attr) !=0:
+        corrMatrixArgs = attr
+    else:
+        corrMatrixArgs = request.json['corrMatrix_args']
+        individual = request.json['individual']
+    if len(corrMatrixArgs) < 2:
+        return {}
+    if len(corrMatrixArgs) > 24:
+        return{}
+
+    df = pd.DataFrame(columns = [c for c in corrMatrixArgs])
+    if individual:
+        if not id:
+            id = request.json['id']
+        d = individualCorrMatrixData(id, corrMatrixArgs)
+        df = d
+        # df = d.loc[:, d.columns.isin(corrMatrixArgs)]
+    else:
+        df = inputData.loc[:, inputData.columns.isin(corrMatrixArgs)]
+
+    corrMatrix = df.corr(method="spearman").fillna(0)
+    return corrMatrix.to_dict()
+
+
+
+@app.route("/getDerivedAttributes")
+def getDerivedAttributes():
+    if not len(rawDataArgs):
+        return {"facial": [], "acoustic":[], "movement":[], "speech": [], "ids": []}
+
+    res={"facial": rawDataArgs['facialAttr'], "acoustic": rawDataArgs['acousticAttr'], "movement": rawDataArgs['movementAttr'], 
+    "speech": rawDataArgs["speechAttr"], "ids": rawDataArgs['ids']}
+    return res
+
+@app.route("/getMetadata")
+def getMetadata():
+    if not len(metadata):
+        return {}
+
+    return metadata
+
+def load():
+    global rawDataArgs, metadata
+    rawDataArgs = process_input_data.read_derivedAttr(sys.argv[1])
+    if len(sys.argv) >2:
+        metadata = process_input_data.read_medatada(sys.argv[1], sys.argv[2])
+    else:
+        metadata=[]
+    global inputData
+    inputData = process_input_data.read_derivedDf(sys.argv[1])
+    if len(inputData):
+        inputData['Filename'] = inputData['Filename'].apply(lambda x: x.split('/')[1].replace(".mp4", ""))
+    else:
+        inputData['Filename'] = [""]
+    global individualFacialRawData, individualDerivedData, individualAcousticRawData, individualMovementRawData
+    individualFacialRawData = process_input_data.read_rawFacialDf(sys.argv[1], inputData['Filename'][0])
+    individualMovementRawData  = process_input_data.read_rawMovementDf(sys.argv[1], inputData['Filename'][0])
+    individualAcousticRawData = process_input_data.read_rawAcousticDf(sys.argv[1], inputData['Filename'][0])
+
+
+if __name__=="__main__":
+    # from waitress import serve
+
+    load()
+    # serve(app, host='127.0.0.1', port=5000)
+    app.run(debug=True)
+    # app.run(debug=False)