# Introducing callbacks

# -*- coding: utf-8 -*-

import base64

import time

import dash

import dash_core_components as dcc

import dash_html_components as html

import dash_daq as daq

import pandas as pd

import numpy as np

import numpy as np

import cv2

# prepare the data -- begin

cases = pd.read_csv('../data/valid-acl.csv',

                    header=None,

                    names=['Case', 'Abnormal'],

                    dtype={'Case': str, 'Abnormal': np.int64}

                    )

case_list = cases['Case'].tolist()

predictions = pd.read_csv('./val_data.csv')

# prepare the data -- end

app = dash.Dash(show_undo_redo=False)

# Boostrap CSS.

app.css.append_css({'external_url': 'https://codepen.io/amyoshino/pen/jzXypZ.css'})  # noqa: E501

#app.css.append_css({'external_url': "https://stackpath.bootstrapcdn.com/bootstrap/3.4.1/css/bootstrap.min.css"})  # noqa: E501

app.layout = html.Div(

    html.Div([

        html.Div(

                html.H1(children='Interpretation of MRNet models through Class Activation Maps (CAM)', 

                        className='twelve columns',

                        style={'text-align': 'center'}                      

                    )

            ,

            className="row",

        ),

        html.Div(

            [

                html.Div(

                    [

                        html.P('Select a medical case (i.e. a patient)'),

                        html.Div([

                            dcc.Dropdown(

                                id='cases',

                                options=[

                                    {'label': case, 'value': case} for case in case_list

                                ],

                                placeholder="Pick a case",

                                clearable=False

                            )

                        ],

                            style={'margin-bottom': 20}

                        ),

                    ],

                    className='three columns',

                    style={'margin-top': '10'}

                ),

                html.Div([

                    html.Div([

                        html.Div([

                            html.P('Select true labels :'),

                            dcc.RadioItems(

                                id="label_radioitems",

                                options=[

                                    {'label': 'Positive (ACL tear)', 'value': 'acl'},

                                    {'label': 'Negative (Normal)', 'value': 'normal'},

                                ],

                                value='acl',

                                labelStyle={'display': 'inline-block'}

                            ),

                        ],

                            style={'float': 'left', 'width': '45%'}

                        ),

                        html.Div([

                            html.P('Select predicted labels :'),

                            dcc.RadioItems(

                                id="pred_radioitems",

                                options=[

                                    {'label': 'Positive (ACL tear)', 'value': 'acl'},

                                    {'label': 'Negative (Normal)', 'value': 'normal'},

                                ],

                                value='acl',

                                labelStyle={'display': 'inline-block'}

                            ),

                        ]

                        ),

                    ]),

                ],

                    className='six columns'

                ),

                html.Div([

                    html.Div(id="number_of_cases"),

                    html.Span(

                            id="label_badge", 

                            className="badge badge-success badge-large",

                            style={'font-size': '15px'}

                            ),

                ],

                    className='three columns'

                )

            ], className="row"

        ),

        html.Div([

            html.Div([

                html.P(id='summary', style={'font-size': '20px'}),

                html.Div([

                        html.Div('This probability is a weighted average of the three probabilities of tears over each plane', style={'float': 'left', 'font-size': '20px'}),

                        html.Div('Slide over the slices of each MRI to inspect highlighted regions of tear as depicted by CAMs', style={'float': 'left', 'font-size': '20px'}),

                    ],

                    # style={'text-align': 'center'}

                    )

                    ],

                    className="twelve columns"),

        ],

        className='row'

        ),

        html.Hr(),

        html.Div(

            [

                html.Div([

                    html.Div([

                        dcc.Slider(id='slider_axial', updatemode='drag')

                    ],

                        style={'margin-right': '5px'}

                    ),

                    html.Hr(),

                    html.P(id="score_axial", style={'text-align': 'center'}),

                    html.Div([

                        html.Div([

                            html.Img(

                                id="slice_axial",

                            ),

                        ],

                            style={'float': 'left', 'margin-right': '5px'}

                        ),

                        html.Div([

                            html.Img(

                                id="cam_axial",

                            ),

                        ],

                        )

                    ],

                    ),

                    html.P(id="title_axial", style={'text-align': 'center'})

                ],

                    className="four columns"

                ),

                html.Div([

                    html.Div([

                        dcc.Slider(id='slider_coronal', updatemode='drag')

                    ],

                        style={'margin-right': '5px'}

                    ),

                    html.Hr(),

                    html.P(id="score_coronal", style={'text-align': 'center'}),

                    html.Div([

                        html.Div([

                            html.Img(

                                id="slice_coronal",

                            ),

                        ],

                            style={'float': 'left', 'margin-right': '5px'}

                        ),

                        html.Div([

                            html.Img(

                                id="cam_coronal",

                            ),

                        ],

                        )

                    ],

                    ),

                    html.P(id="title_coronal", style={'text-align': 'center'})

                ],

                    className="four columns"

                ),

                html.Div([

                    html.Div([

                        dcc.Slider(id='slider_sagittal', updatemode='drag')

                    ]),

                    html.Hr(),

                    html.P(id="score_sagittal", style={

                           'text-align': 'center'}),

                    html.Div([

                        html.Div([

                            html.Img(

                                id="slice_sagittal",

                            ),

                        ],

                            style={'float': 'left', 'margin-right': '5px'}

                        ),

                        html.Div([

                            html.Img(

                                id="cam_sagittal",

                            ),

                        ],

                        )

                    ],

                    ),

                    html.P(id="title_sagittal", style={'text-align': 'center'})

                ],

                    className="four columns"

                ),

            ],

            className='row'

        )

    ], className='twelve columns')

)

# select label --- begin

@app.callback(

    dash.dependencies.Output('cases', 'options'),

    [

        dash.dependencies.Input('label_radioitems', 'value'),

        dash.dependencies.Input('pred_radioitems', 'value'),

    ]

)

def set_label(selected_label, selected_pred):

    if (selected_label == 'acl') and (selected_pred == 'acl'):

        filtered_cases = predictions[(predictions['labels'] == 1) & 

                                     (predictions['preds'] >= 0.5)].index.tolist()

    elif (selected_label == 'acl') and (selected_pred == 'normal'):

        filtered_cases = predictions[(predictions['labels'] == 1) & 

                                     (predictions['preds'] < 0.5)].index.tolist()

    elif (selected_label == 'normal') and (selected_pred == 'acl'):

        filtered_cases = predictions[(predictions['labels'] == 0) & 

                                     (predictions['preds'] >= 0.5)].index.tolist()

    elif (selected_label == 'normal') and (selected_pred == 'normal'):

        filtered_cases = predictions[(predictions['labels'] == 0) & 

                                     (predictions['preds'] < 0.5)].index.tolist()                                 

    filtered_cases = [c + 1130 for c in filtered_cases]

    options = [{'label': fc, 'value': fc} for fc in filtered_cases]

    return options

# select label --- end

# set badge label --- begin

@app.callback(

    dash.dependencies.Output('label_badge', 'children'),

    [

        dash.dependencies.Input('label_radioitems', 'value'),

        dash.dependencies.Input('pred_radioitems', 'value'),

    ]

)

def set_badge_label(selected_label, selected_pred):

    if (selected_label == 'acl') and (selected_pred == 'acl'):

        text = 'true positive case'

    elif (selected_label == 'acl') and (selected_pred == 'normal'):

        text = 'false negative case'

    elif (selected_label == 'normal') and (selected_pred == 'acl'):

        text = 'false positive case'

    elif (selected_label == 'normal') and (selected_pred == 'normal'):

        text = 'true negative case'

    return text

# set badge label --- end

# set badge color --- begin

@app.callback(

    dash.dependencies.Output('label_badge', 'className'),

    [

        dash.dependencies.Input('label_radioitems', 'value'),

        dash.dependencies.Input('pred_radioitems', 'value'),

    ]

)

def set_badge_color(selected_label, selected_pred):

    if (selected_label == 'acl') and (selected_pred == 'acl'):

        className = 'badge badge-success'

    elif (selected_label == 'acl') and (selected_pred == 'normal'):

        className = 'badge badge-error'

    elif (selected_label == 'normal') and (selected_pred == 'acl'):

        className = 'badge badge-error'

    elif (selected_label == 'normal') and (selected_pred == 'normal'):

        className = 'badge badge-success'

    return className

# set badge color --- end

# set a case value --- begin

@app.callback(

    dash.dependencies.Output('cases', 'value'),

    [

        dash.dependencies.Input('label_radioitems', 'value'),

        dash.dependencies.Input('pred_radioitems', 'value'),

    ]

)

def set_badge_color(selected_label, selected_pred):

    if (selected_label == 'acl') and (selected_pred == 'acl'):

        filtered_cases = predictions[(predictions['labels'] == 1) & 

                                     (predictions['preds'] >= 0.5)].index.tolist()

    elif (selected_label == 'acl') and (selected_pred == 'normal'):

        filtered_cases = predictions[(predictions['labels'] == 1) & 

                                     (predictions['preds'] < 0.5)].index.tolist()

    elif (selected_label == 'normal') and (selected_pred == 'acl'):

        filtered_cases = predictions[(predictions['labels'] == 0) & 

                                     (predictions['preds'] >= 0.5)].index.tolist()

    elif (selected_label == 'normal') and (selected_pred == 'normal'):

        filtered_cases = predictions[(predictions['labels'] == 0) & 

                                     (predictions['preds'] < 0.5)].index.tolist()                                 

    filtered_cases = [c + 1130 for c in filtered_cases]

    case_value = np.random.choice(filtered_cases)

    return case_value

# set a case value --- end

# set summary --- begin

@app.callback(

    dash.dependencies.Output('summary', 'children'),

    [

        dash.dependencies.Input('cases', 'value'),

        dash.dependencies.Input('label_radioitems', 'value'),

        dash.dependencies.Input('pred_radioitems', 'value')

    ]

)

def set_summary(selected_case, selected_label, selected_pred):

    proba = predictions['preds'].tolist()[int(selected_case) - 1130]

    proba = np.round(proba, 4)

    if (selected_label == 'acl') and (selected_pred == 'acl'):

        status = 'correctly'

    elif (selected_label == 'acl') and (selected_pred == 'normal'):

        status = 'incorrectly'

    elif (selected_label == 'normal') and (selected_pred == 'acl'):

        status = 'incorrectly'

    elif (selected_label == 'normal') and (selected_pred == 'normal'):

        status = 'correctly'

    if selected_pred == 'acl':

        summary = f'This patient, denoted by the MRI exam n°{selected_case}, is {status} diagnosed with an ACL tear with an ACL tear probability of {proba}'

    elif selected_pred == 'normal':

        summary = f'This patient, denoted by the MRI exam n°{selected_case}, is {status} diagnosed to be normal with an ACL tear probability of {proba}'

    return summary

# set summary --- end

# set number of cases --- begin

@app.callback(

    dash.dependencies.Output('number_of_cases', 'children'),

    [

        dash.dependencies.Input('label_radioitems', 'value'),

        dash.dependencies.Input('pred_radioitems', 'value')

    ]

)

def set_number_cases(selected_label, selected_pred):

    if (selected_label == 'acl') and (selected_pred == 'acl'):

        n = predictions[(predictions['labels'] == 1) & 

                                     (predictions['preds'] >= 0.5)].shape[0]

    elif (selected_label == 'acl') and (selected_pred == 'normal'):

        n = predictions[(predictions['labels'] == 1) & 

                                     (predictions['preds'] < 0.5)].shape[0]

    elif (selected_label == 'normal') and (selected_pred == 'acl'):

        n = predictions[(predictions['labels'] == 0) & 

                                     (predictions['preds'] >= 0.5)].shape[0]

    elif (selected_label == 'normal') and (selected_pred == 'normal'):

        n = predictions[(predictions['labels'] == 0) & 

                                     (predictions['preds'] < 0.5)].shape[0]                                 

    msg = f"{n} MRI exams"

    return msg

# set number of cases --- end

# update axial slider --- begin

@app.callback(

    dash.dependencies.Output('slider_axial', 'value'),

    [

        dash.dependencies.Input('cases', 'value'),

    ]

)

def set_slider_value_axial(selected_case):

    mri = np.load(f'../data/valid/axial/{selected_case}.npy')

    number_slices = mri.shape[0]

    return number_slices // 2

@app.callback(

    dash.dependencies.Output('slider_axial', 'max'),

    [

        dash.dependencies.Input('cases', 'value'),

    ]

)

def set_slider_max_axial(selected_case):

    mri = np.load(f'../data/valid/axial/{selected_case}.npy')

    number_slices = mri.shape[0]

    return number_slices - 1

@app.callback(

    dash.dependencies.Output('slider_axial', 'marks'),

    [

        dash.dependencies.Input('cases', 'value'),

    ]

)

def set_slider_marks_axial(selected_case):

    mri = np.load(f'../data/valid/axial/{selected_case}.npy')

    number_slices = mri.shape[0]

    marks = {str(i): '{}'.format(i) for i in range(number_slices)[::2]}

    return marks

# update axial slider --- end

# update coronal slider --- begin

@app.callback(

    dash.dependencies.Output('slider_coronal', 'value'),

    [

        dash.dependencies.Input('cases', 'value'),

    ]

)

def set_slider_value_coronal(selected_case):

    mri = np.load(f'../data/valid/coronal/{selected_case}.npy')

    number_slices = mri.shape[0]

    return number_slices // 2

@app.callback(

    dash.dependencies.Output('slider_coronal', 'max'),

    [

        dash.dependencies.Input('cases', 'value'),

    ]

)

def set_slider_max_coronal(selected_case):

    mri = np.load(f'../data/valid/coronal/{selected_case}.npy')

    number_slices = mri.shape[0]

    return number_slices - 1

@app.callback(

    dash.dependencies.Output('slider_coronal', 'marks'),

    [

        dash.dependencies.Input('cases', 'value'),

    ]

)

def set_slider_marks_coronal(selected_case):

    mri = np.load(f'../data/valid/coronal/{selected_case}.npy')

    number_slices = mri.shape[0]

    marks = {str(i): '{}'.format(i) for i in range(number_slices)[::2]}

    return marks

# update coronal slider --- end

# update sagittal slider --- begin

@app.callback(

    dash.dependencies.Output('slider_sagittal', 'value'),

    [

        dash.dependencies.Input('cases', 'value'),

    ]

)

def set_slider_value_sagittal(selected_case):

    mri = np.load(f'../data/valid/sagittal/{selected_case}.npy')

    number_slices = mri.shape[0]

    return number_slices // 2

@app.callback(

    dash.dependencies.Output('slider_sagittal', 'max'),

    [

        dash.dependencies.Input('cases', 'value'),

    ]

)

def set_slider_max_sagittal(selected_case):

    mri = np.load(f'../data/valid/sagittal/{selected_case}.npy')

    number_slices = mri.shape[0]

    return number_slices - 1

@app.callback(

    dash.dependencies.Output('slider_sagittal', 'marks'),

    [

        dash.dependencies.Input('cases', 'value'),

    ]

)

def set_slider_marks_sagittal(selected_case):

    mri = np.load(f'../data/valid/sagittal/{selected_case}.npy')

    number_slices = mri.shape[0]

    marks = {str(i): '{}'.format(i) for i in range(number_slices)[::2]}

    return marks

# update sagittal slider --- end

# update slider --- END

# Axial

##########################################################################

# write number of slice axial - begin

@app.callback(

    dash.dependencies.Output('title_axial', 'children'),

    [

        dash.dependencies.Input('cases', 'value'),

        dash.dependencies.Input('slider_axial', 'value')

    ]

)

def write_num_slice_axial(selected_case, selected_slice):

    case = np.load(f'../data/valid/axial/{selected_case}.npy')

    num_slices = case.shape[0]

    title = f'Visualization of slice n°{selected_slice}/{num_slices} and its corresponding CAM'

    return title

# write number of slice axial - end

# write score axial - begin

@app.callback(

    dash.dependencies.Output('score_axial', 'children'),

    [

        dash.dependencies.Input('cases', 'value'),

    ]

)

def write_score_axial(selected_case):

    score = predictions.iloc[int(selected_case) - 1130]['axial']

    score = np.round(score, 4)

    msg = f"ACL tear proba on axial plane : {score}"

    return msg

# write score axial

# update slice axial --- begin

@app.callback(

    dash.dependencies.Output('slice_axial', 'src'),

    [

        dash.dependencies.Input('cases', 'value'),

        dash.dependencies.Input('slider_axial', 'value'),

    ])

def update_slice_axial(selected_case, selected_slice):

    s = np.load(f'../data/valid/axial/{selected_case}.npy')[selected_slice]

    cv2.imwrite(f'./slice_axial.png', s)

    encoded_image = base64.b64encode(open('./slice_axial.png', 'rb').read())

    return 'data:image/png;base64,{}'.format(encoded_image.decode())

# update slice axial --- end

# update cam axial --- begin

@app.callback(

    dash.dependencies.Output('cam_axial', 'src'),

    [

        dash.dependencies.Input('cases', 'value'),

        dash.dependencies.Input('slider_axial', 'value'),

    ])

def update_cam_axial(selected_case, selected_slice):

    selected_case = int(selected_case) - 1130

    selected_case = '0' * (4 - len(str(selected_case))) + str(selected_case)

    src = f'./CAMS/axial/{selected_case}/cams/{selected_slice}.png'

    encoded_image = base64.b64encode(open(src, 'rb').read())

    return 'data:image/png;base64,{}'.format(encoded_image.decode())

# update slice axial --- end

# Coronal

##########################################################################

# write number of slice coronal - begin

@app.callback(

    dash.dependencies.Output('title_coronal', 'children'),

    [

        dash.dependencies.Input('cases', 'value'),

        dash.dependencies.Input('slider_coronal', 'value')

    ]

)

def write_num_slice_coronal(selected_case, selected_slice):

    case = np.load(f'../data/valid/coronal/{selected_case}.npy')

    num_slices = case.shape[0]

    title = f'Visualization of slice n°{selected_slice}/{num_slices} and its corresponding CAM'

    return title

# write number of slice coronal - end

# write score coronal - begin

@app.callback(

    dash.dependencies.Output('score_coronal', 'children'),

    [

        dash.dependencies.Input('cases', 'value'),

    ]

)

def write_score_coronal(selected_case):

    score = predictions.iloc[int(selected_case) - 1130]['coronal']

    score = np.round(score, 4)

    msg = f"ACL tear proba on coronal plane : {score}"

    return msg

# write score coronal

# update slice coronal --- begin

@app.callback(

    dash.dependencies.Output('slice_coronal', 'src'),

    [

        dash.dependencies.Input('cases', 'value'),

        dash.dependencies.Input('slider_coronal', 'value'),

    ])

def update_slice_coronal(selected_case, selected_slice):

    s = np.load(f'../data/valid/coronal/{selected_case}.npy')[selected_slice]

    cv2.imwrite(f'./slice_coronal.png', s)

    encoded_image = base64.b64encode(open('./slice_coronal.png', 'rb').read())

    return 'data:image/png;base64,{}'.format(encoded_image.decode())

# update slice coronal --- end

# update cam coronal --- begin

@app.callback(

    dash.dependencies.Output('cam_coronal', 'src'),

    [

        dash.dependencies.Input('cases', 'value'),

        dash.dependencies.Input('slider_coronal', 'value'),

    ])

def update_cam_coronal(selected_case, selected_slice):

    selected_case = int(selected_case) - 1130

    selected_case = '0' * (4 - len(str(selected_case))) + str(selected_case)

    src = f'./CAMS/coronal/{selected_case}/cams/{selected_slice}.png'

    encoded_image = base64.b64encode(open(src, 'rb').read())

    return 'data:image/png;base64,{}'.format(encoded_image.decode())

# update slice coronal --- end

# Sagittal

##########################################################################

# write number of slice sagittal - begin

@app.callback(

    dash.dependencies.Output('title_sagittal', 'children'),

    [

        dash.dependencies.Input('cases', 'value'),

        dash.dependencies.Input('slider_sagittal', 'value')

    ]

)

def write_num_slice_sagittal(selected_case, selected_slice):

    case = np.load(f'../data/valid/sagittal/{selected_case}.npy')

    num_slices = case.shape[0]

    title = f'Visualization of slice n°{selected_slice}/{num_slices} and its corresponding CAM'

    return title

# write number of slice sagittal - end

# write score sagittal - begin

@app.callback(

    dash.dependencies.Output('score_sagittal', 'children'),

    [

        dash.dependencies.Input('cases', 'value'),

    ]

)

def write_score_sagittal(selected_case):

    score = predictions.iloc[int(selected_case) - 1130]['sagittal']

    score = np.round(score, 4)

    msg = f"ACL tear proba on sagittal plane : {score}"

    return msg

# write score sagittal

# update slice sagittal --- begin

@app.callback(

    dash.dependencies.Output('slice_sagittal', 'src'),

    [

        dash.dependencies.Input('cases', 'value'),

        dash.dependencies.Input('slider_sagittal', 'value'),

    ])

def update_slice_sagittal(selected_case, selected_slice):

    s = np.load(f'../data/valid/sagittal/{selected_case}.npy')[selected_slice]

    cv2.imwrite(f'./slice_sagittal.png', s)

    encoded_image = base64.b64encode(open('./slice_sagittal.png', 'rb').read())

    return 'data:image/png;base64,{}'.format(encoded_image.decode())

# update slice saigttal --- end

# update cam sagittal --- begin

@app.callback(

    dash.dependencies.Output('cam_sagittal', 'src'),

    [

        dash.dependencies.Input('cases', 'value'),

        dash.dependencies.Input('slider_sagittal', 'value'),

    ])

def update_cam_sagittal(selected_case, selected_slice):

    selected_case = int(selected_case) - 1130

    selected_case = '0' * (4 - len(str(selected_case))) + str(selected_case)

    src = f'./CAMS/sagittal/{selected_case}/cams/{selected_slice}.png'

    encoded_image = base64.b64encode(open(src, 'rb').read())

    return 'data:image/png;base64,{}'.format(encoded_image.decode())

# update slice coronal --- end

if __name__ == '__main__':

    app.run_server(debug=True)