from __future__ import print_function, division
import tensorflow as tf
import numpy as np


# --------------------------- BINARY Evaluation ---------------------------
def binary_iou(Y_pred, Y_gt, prob=0.5):
    """
    binary iou
    :param Y_pred:A tensor resulting from a sigmod
    :param Y_gt:A tensor of the same shape as `output`
    :return: binary iou
    """
    Y_pred_part = tf.to_float(Y_pred > prob)
    Y_pred_part = tf.cast(Y_pred_part, tf.float32)
    Y_gt_part = tf.identity(Y_gt)
    Y_gt_part = tf.cast(Y_gt_part, tf.float32)
    Z, H, W, C = Y_gt.get_shape().as_list()[1:]
    smooth = 1.e-5
    smooth_tf = tf.constant(smooth, tf.float32)
    pred_flat = tf.reshape(Y_pred_part, [-1, H * W * C * Z])
    true_flat = tf.reshape(Y_gt_part, [-1, H * W * C * Z])
    intersection = tf.reduce_sum(pred_flat * true_flat, axis=-1)
    union = tf.reduce_sum(pred_flat, axis=-1) + tf.reduce_sum(true_flat, axis=-1) - intersection
    metric = tf.reduce_mean((intersection + smooth_tf) / (union + smooth_tf))
    metric = tf.cond(tf.is_inf(metric), lambda: smooth_tf, lambda: metric)
    return metric


# --------------------------- BINARY LOSSES ---------------------------
def binary_crossentropy(Y_pred, Y_gt):
    """
    Binary crossentropy between an output tensor and a target tensor.
    :param Y_pred:A tensor with (batchsize,z,x,y,channel)from a sigmod,probability distribution.
    :param Y_gt:A tensor with the same shape as `output`.
    :return:binary_crossentropy
    """
    epsilon = 1.e-5
    Y_pred = tf.clip_by_value(Y_pred, epsilon, 1. - epsilon)
    logits = tf.log(Y_pred / (1 - Y_pred))
    loss = tf.nn.sigmoid_cross_entropy_with_logits(labels=Y_gt, logits=logits)
    loss = tf.reduce_mean(loss)
    return loss


def weighted_binary_crossentroy(Y_pred, Y_gt, beta):
    """
    Weighted cross entropy (WCE) is a variant of CE where all positive examples get weighted by some coefficient.
    It is used in the case of class imbalance.
    For example, when you have an image with 10% black pixels and 90% white pixels, regular CE won’t work very well.
    WCE define:wce(p',p)=-(b*p*log(p')+(1-p)*log(1-p'))
    :param Y_pred:A tensor with (batchsize,z,x,y,channel)from a sigmod,probability distribution.
    :param Y_gt:A tensor with the same shape as `output`.
    :param beta: To decrease the number of false negatives, setβ>1. To decrease the number of false positives, set β<1.
    :return:weighted_binary_crossentroy
    """
    epsilon = 1.e-5
    Y_pred = tf.clip_by_value(Y_pred, epsilon, 1. - epsilon)
    logits = tf.log(Y_pred / (1 - Y_pred))
    loss = tf.nn.weighted_cross_entropy_with_logits(targets=Y_gt, logits=logits, pos_weight=beta)
    loss = tf.reduce_mean(loss)
    return loss


def balanced_binary_crossentroy(Y_pred, Y_gt, beta):
    """
    Balanced cross entropy (BCE) is similar to WCE. The only difference is that we weight also the negative examples
    bce define:bce(p',p)=-(b*p*log(p')+(1-b)*(1-p)*log(1-p'))
    :param Y_pred:A tensor with (batchsize,z,x,y,channel)from a sigmod,probability distribution.
    :param Y_gt:A tensor with the same shape as `output`.
    :param beta: β!=1,the denominator in pos_weight is not defined
    such as：beta = tf.reduce_sum(1 - y_true) / (BATCH_SIZE * HEIGHT * WIDTH)
    :return:
    """
    epsilon = 1.e-5
    Y_pred = tf.clip_by_value(Y_pred, epsilon, 1. - epsilon)
    logits = tf.log(Y_pred / (1 - Y_pred))
    beta = tf.clip_by_value(beta, epsilon, 1 - epsilon)
    pos_weight = beta / (1 - beta)
    loss = tf.nn.weighted_cross_entropy_with_logits(targets=Y_gt, logits=logits, pos_weight=pos_weight)
    loss = tf.reduce_mean(loss * (1 - beta))
    return loss


def binary_dice(Y_pred, Y_gt):
    """
    binary dice loss
    loss=2*(p&p')/(p+p')
    :param Y_pred: A tensor resulting from a sigmod
    :param Y_gt:  A tensor of the same shape as `output`
    :return: binary dice loss
    """
    smooth = 1.e-5
    smooth_tf = tf.constant(smooth, tf.float32)
    pred_flat = tf.cast(Y_pred, tf.float32)
    true_flat = tf.cast(Y_gt, tf.float32)
    intersection = 2 * tf.reduce_sum(pred_flat * true_flat, axis=-1) + smooth_tf
    denominator = tf.reduce_sum(pred_flat, axis=-1) + tf.reduce_sum(true_flat, axis=-1) + smooth_tf
    loss = -tf.reduce_mean(intersection / denominator)
    return loss


def binary_tversky(Y_pred, Y_gt, beta):
    """
    Tversky loss (TL) is a generalization of Dice loss. TL adds a weight to FP and FN.
    define:TL(p,p')=(p&p')/(p&p'+b*((1-p)&p')+(1-b)*(p&(1-p')))
    :param Y_pred:A tensor resulting from a sigmod
    :param Y_gt:A tensor of the same shape as `output`
    :param beta:beta=1/2,just Dice loss,beta must(0,1)
    :return:
    """
    smooth = 1.e-5
    smooth_tf = tf.constant(smooth, tf.float32)
    pred_flat = tf.cast(Y_pred, tf.float32)
    true_flat = tf.cast(Y_gt, tf.float32)
    intersection = tf.reduce_sum(pred_flat * true_flat, axis=-1) + smooth_tf
    denominator = intersection + tf.reduce_sum(beta * pred_flat * (1 - true_flat), axis=-1) + \
                  tf.reduce_sum((1 - beta) * true_flat * (1 - pred_flat), axis=-1) + smooth_tf
    loss = -tf.reduce_mean(intersection / denominator)
    return loss


def binary_dicePcrossentroy(Y_pred, Y_gt, lamda=1):
    """
    plus dice and crossentroy loss
    :param Y_pred:A tensor resulting from a sigmod
    :param Y_gt:A tensor of the same shape as `output`
    :param lamda:can set 0.1,0.5,1
    :return:dice+crossentroy
    """
    # step 1,calculate binary crossentroy
    loss1 = binary_crossentropy(Y_pred, Y_gt)
    # step 2,calculate binary dice
    loss2 = 1 - binary_dice(Y_pred, Y_gt)
    # step 3,calculate all loss mean
    loss = lamda * loss1 + tf.log1p(loss2)
    return loss


def binary_focalloss(Y_pred, Y_gt, alpha=0.25, gamma=2.):
    """
    Binary focal loss.
    FL(p_t) = -alpha * (1 - p_t)**gamma * log(p_t)
    where p = sigmoid(x), p_t = p or 1 - p depending on if the label is 1 or 0, respectively.
    :param Y_gt: A tensor of the same shape as `y_pred`
    :param Y_pred: A tensor resulting from a sigmoid
    :param alpha: Sample category weight
    :param gamma: Difficult sample weight
    :return: Binary focal loss.
    """
    epsilon = 1.e-5
    pt_1 = tf.where(tf.equal(Y_gt, 1), Y_pred, tf.ones_like(Y_pred))
    pt_0 = tf.where(tf.equal(Y_gt, 0), Y_pred, tf.zeros_like(Y_pred))
    # clip to prevent NaN's and Inf's
    pt_1 = tf.clip_by_value(pt_1, epsilon, 1. - epsilon)
    pt_0 = tf.clip_by_value(pt_0, epsilon, 1. - epsilon)
    loss_1 = alpha * tf.pow(1. - pt_1, gamma) * tf.log(pt_1)
    loss_0 = (1 - alpha) * tf.pow(pt_0, gamma) * tf.log(1. - pt_0)
    loss = -tf.reduce_sum(loss_1 + loss_0)
    loss = tf.reduce_mean(loss)
    return loss


def binary_distanceloss(Y_pred, Y_gt):
    """
    distance loss,make segmentation network more sensitive to the boundaries
    can use with cross entroy ,dice together,but should have mutilfy weighting coefficient
    :param Y_pred:A tensor resulting from a sigmoid
    :param Y_gt:A tensor of the same shape as `y_pred`
    :return:
    """
    pred_flat = tf.cast(Y_pred, tf.float32)
    true_flat = tf.cast(Y_gt, tf.float32)

    def Edge_Extracted(y_pred):
        # Edge extracted by sobel filter
        min_x = tf.constant(0, tf.float32)
        max_x = tf.constant(1, tf.float32)
        sobel_x = tf.constant([[[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]],
                               [[-2, 0, 2], [-4, 0, 4], [-2, 0, 2]],
                               [[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]], tf.float32)
        sobel_x_filter = tf.reshape(sobel_x, [3, 3, 3, 1, 1])
        sobel_y_filter = tf.transpose(sobel_x_filter, [0, 2, 1, 3, 4])
        filters_x = tf.nn.conv3d(y_pred, sobel_x_filter, strides=[1, 1, 1, 1, 1], padding='SAME')
        filters_y = tf.nn.conv3d(y_pred, sobel_y_filter, strides=[1, 1, 1, 1, 1], padding='SAME')
        edge = tf.sqrt(filters_x * filters_x + filters_y * filters_y + 1e-16)
        edge = tf.clip_by_value(edge, min_x, max_x)
        return edge

    Y_pred_edge = Edge_Extracted(pred_flat)
    Y_gt_edge = Edge_Extracted(true_flat)
    distanceloss = tf.reduce_sum(Y_gt_edge * Y_pred_edge, axis=-1)
    return distanceloss


# --------------------------- MULTICLASS Evaluation ---------------------------

def mean_iou(Y_pred, Y_gt):
    """
    Mean Intersection-Over-Union is a common evaluation metric for
    semantic image segmentation, which first computes the IOU for each
    semantic class and then computes the average over classes,but label 0 is background,general background is more big,
    so mean iou calculate don't include background
    :param Y_pred: [None, self.image_depth, self.image_height, self.image_width,
                                                       self.numclass],Y_pred is softmax result
    :param Y_gt: [None, self.image_depth, self.image_height, self.image_width,
                                                       self.numclass],Y_gt is one hot result
    :return: mean_iou
    """
    num_class = Y_pred.get_shape().as_list()[-1]
    Y_pred_part = tf.one_hot(tf.argmax(Y_pred, axis=-1), num_class)
    Y_pred_part = tf.cast(Y_pred_part, tf.float32)
    Y_pred_part = Y_pred_part[:, :, :, :, 1:num_class]
    Y_gt_part = tf.cast(Y_gt, tf.float32)
    Y_gt_part = Y_gt_part[:, :, :, :, 1:num_class]
    Z, H, W, C = Y_gt.get_shape().as_list()[1:]
    smooth = 1.e-5
    smooth_tf = tf.constant(smooth, tf.float32)
    pred_flat = tf.reshape(Y_pred_part, [-1, H * W * Z])
    true_flat = tf.reshape(Y_gt_part, [-1, H * W * Z])
    intersection = tf.reduce_sum(pred_flat * true_flat, axis=-1)
    union = tf.reduce_sum(pred_flat, axis=-1) + tf.reduce_sum(true_flat, axis=-1) - intersection
    metric = tf.reduce_mean((intersection + smooth_tf) / (union + smooth_tf))
    metric = tf.cond(tf.is_inf(metric), lambda: smooth_tf, lambda: metric)
    return metric


def mean_dice(Y_pred, Y_gt):
    """
    Mean dice is a common evaluation metric for
    semantic image segmentation, which first computes the dice for each
    semantic class and then computes the average over classes,but label 0 is background,general background is more big,
    so mean dice calculate don't include background
    :param Y_pred: [None, self.image_depth, self.image_height, self.image_width,
                                                       self.numclass],Y_pred is softmax result
    :param Y_gt: [None, self.image_depth, self.image_height, self.image_width,
                                                       self.numclass],Y_gt is one hot result
    :return: mean_iou
    """
    num_class = Y_pred.get_shape().as_list()[-1]
    Y_pred_part = tf.one_hot(tf.argmax(Y_pred, axis=-1), num_class)
    Y_pred_part = tf.cast(Y_pred_part, tf.float32)
    Y_pred_part = Y_pred_part[:, :, :, :, 1:num_class]
    Y_gt_part = tf.cast(Y_gt, tf.float32)
    Y_gt_part = Y_gt_part[:, :, :, :, 1:num_class]
    Z, H, W, C = Y_gt.get_shape().as_list()[1:]
    smooth = 1.e-5
    smooth_tf = tf.constant(smooth, tf.float32)
    pred_flat = tf.reshape(Y_pred_part, [-1, H * W * Z])
    true_flat = tf.reshape(Y_gt_part, [-1, H * W * Z])
    intersection = 2 * tf.reduce_sum(pred_flat * true_flat, axis=-1)
    union = tf.reduce_sum(pred_flat, axis=-1) + tf.reduce_sum(true_flat, axis=-1)
    metric = tf.reduce_mean((intersection + smooth_tf) / (union + smooth_tf))
    metric = tf.cond(tf.is_inf(metric), lambda: smooth_tf, lambda: metric)
    return metric


# --------------------------- MULTICLASS LOSSES ---------------------------
def categorical_crossentropy(Y_pred, Y_gt):
    """
    Categorical crossentropy between an output and a target
    loss=-y*log(y')
    :param Y_pred: A tensor resulting from a softmax
    :param Y_gt:  A tensor of the same shape as `output`
    :return:categorical_crossentropy loss
    """
    epsilon = 1.e-5
    # scale preds so that the class probas of each sample sum to 1
    output = Y_pred / tf.reduce_sum(Y_pred, axis=- 1, keep_dims=True)
    # manual computation of crossentropy
    output = tf.clip_by_value(output, epsilon, 1. - epsilon)
    loss = -Y_gt * tf.log(output)
    loss = tf.reduce_sum(loss, axis=(1, 2, 3))
    loss = tf.reduce_mean(loss, axis=0)
    loss = tf.reduce_mean(loss)
    return loss


def weighted_categorical_crossentropy(Y_pred, Y_gt, weights):
    """
    weighted_categorical_crossentropy between an output and a target
    loss=-weight*y*log(y')
    :param Y_pred:A tensor resulting from a softmax
    :param Y_gt:A tensor of the same shape as `output`
    :param weights:numpy array of shape (C,) where C is the number of classes
    :return:categorical_crossentropy loss
    Usage:
    weights = np.array([0.5,2,10]) # Class one at 0.5, class 2 twice the normal weights, class 3 10x.
    """
    weights = np.array(weights)
    epsilon = 1.e-5
    # scale preds so that the class probas of each sample sum to 1
    output = Y_pred / tf.reduce_sum(Y_pred, axis=- 1, keep_dims=True)
    # manual computation of crossentropy
    output = tf.clip_by_value(output, epsilon, 1. - epsilon)
    loss = - Y_gt * tf.log(output)
    loss = tf.reduce_sum(loss, axis=(1, 2, 3))
    loss = tf.reduce_mean(loss, axis=0)
    loss = tf.reduce_mean(weights * loss)
    return loss


def categorical_dice(Y_pred, Y_gt, weight_loss):
    """
    multi label dice loss with weighted
    WDL=1-2*(sum(w*sum(r&p))/sum((w*sum(r+p)))),w=array of shape (C,)
    :param Y_pred: [None, self.image_depth, self.image_height, self.image_width,
                                                       self.numclass],Y_pred is softmax result
    :param Y_gt:[None, self.image_depth, self.image_height, self.image_width,
                                                       self.numclass],Y_gt is one hot result
    :param weight_loss: numpy array of shape (C,) where C is the number of classes
    :return:
    """
    weight_loss = np.array(weight_loss)
    smooth = 1.e-5
    smooth_tf = tf.constant(smooth, tf.float32)
    Y_pred = tf.cast(Y_pred, tf.float32)
    Y_gt = tf.cast(Y_gt, tf.float32)
    # Compute gen dice coef:
    numerator = Y_gt * Y_pred
    numerator = tf.reduce_sum(numerator, axis=(1, 2, 3))
    denominator = Y_gt + Y_pred
    denominator = tf.reduce_sum(denominator, axis=(1, 2, 3))
    gen_dice_coef = tf.reduce_mean(2. * (numerator + smooth_tf) / (denominator + smooth_tf), axis=0)
    loss = -tf.reduce_mean(weight_loss * gen_dice_coef)
    return loss


def categorical_tversky(Y_pred, Y_gt, beta, weight_loss):
    """
    multi label tversky with weighted
    Tversky loss (TL) is a generalization of Dice loss. TL adds a weight to FP and FN.
    define:TL(p,p')=(p&p')/(p&p'+b*((1-p)&p')+(1-b)*(p&(1-p')))
    :param Y_pred: [None, self.image_depth, self.image_height, self.image_width,
                                                       self.numclass],Y_pred is softmax result
    :param Y_gt:[None, self.image_depth, self.image_height, self.image_width,
                                                       self.numclass],Y_gt is one hot result
    :param beta:beta=1/2,just Dice loss,beta must(0,1)
    :return:
    """
    weight_loss = np.array(weight_loss)
    smooth = 1.e-5
    smooth_tf = tf.constant(smooth, tf.float32)
    Y_pred = tf.cast(Y_pred, tf.float32)
    Y_gt = tf.cast(Y_gt, tf.float32)
    p0 = Y_pred
    p1 = 1 - Y_pred
    g0 = Y_gt
    g1 = 1 - Y_gt
    # Compute gen dice coef:
    numerator = p0 * g0
    numerator = tf.reduce_sum(numerator, axis=(1, 2, 3))
    denominator = tf.reduce_sum(beta * p0 * g1, axis=(1, 2, 3)) + tf.reduce_sum((1 - beta) * p1 * g0,
                                                                                axis=(1, 2, 3)) + numerator
    gen_dice_coef = tf.reduce_mean((numerator + smooth_tf) / (denominator + smooth_tf), axis=0)
    loss = -tf.reduce_mean(weight_loss * gen_dice_coef)
    return loss


def generalized_dice_loss_w(Y_pred, Y_gt):
    """
    Generalized Dice Loss with class weights
    GDL=1-2*(sum(w*sum(r*p))/sum((w*sum(r+p)))),w=1/sum(r)*sum(r)
    rln为类别l在第n个像素的标准值(GT)，而pln为相应的预测概率值。此处最关键的是wl,为每个类别的权重
    :param Y_gt:[None, self.image_depth, self.image_height, self.image_width,
                                                       self.numclass],Y_gt is one hot result
    :param Y_pred:[None, self.image_depth, self.image_height, self.image_width,
                                                       self.numclass],Y_pred is softmax result
    :return:
    """
    smooth = 1.e-5
    smooth_tf = tf.constant(smooth, tf.float32)
    Y_pred = tf.cast(Y_pred, tf.float32)
    Y_gt = tf.cast(Y_gt, tf.float32)
    # Compute weights: "the contribution of each label is corrected by the inverse of its volume"
    weight_loss = tf.reduce_sum(Y_gt, axis=(0, 1, 2, 3))
    weight_loss = 1 / (tf.pow(weight_loss, 2) + smooth_tf)
    # Compute gen dice coef:
    numerator = Y_gt * Y_pred
    numerator = weight_loss * tf.reduce_sum(numerator, axis=(0, 1, 2, 3))
    numerator = tf.reduce_sum(numerator)
    denominator = Y_gt + Y_pred
    denominator = weight_loss * tf.reduce_sum(denominator, axis=(0, 1, 2, 3))
    denominator = tf.reduce_sum(denominator)
    loss = -2 * (numerator + smooth_tf) / (denominator + smooth_tf)
    return loss


def categorical_focal_loss(Y_pred, Y_gt, gamma, alpha):
    """
     Categorical focal_loss between an output and a target
    :param Y_pred: A tensor of the same shape as `y_pred`
    :param Y_gt: A tensor resulting from a softmax(-1,z,h,w,numclass)
    :param alpha: Sample category weight,which is shape (C,) where C is the number of classes
    :param gamma: Difficult sample weight
    :return:
    """
    weight_loss = np.array(alpha)
    epsilon = 1.e-5
    # Scale predictions so that the class probas of each sample sum to 1
    output = Y_pred / tf.reduce_sum(Y_pred, axis=- 1, keepdims=True)
    # Clip the prediction value to prevent NaN's and Inf's
    output = tf.clip_by_value(output, epsilon, 1. - epsilon)
    # Calculate Cross Entropy
    cross_entropy = -Y_gt * tf.log(output)
    # Calculate Focal Loss
    loss = tf.pow(1 - output, gamma) * cross_entropy
    loss = tf.reduce_sum(loss, axis=(1, 2, 3))
    loss = tf.reduce_mean(loss, axis=0)
    loss = tf.reduce_mean(weight_loss * loss)
    return loss


def categorical_dicePcrossentroy(Y_pred, Y_gt, weight, lamda=0.5):
    """
    hybrid loss function from dice loss and crossentroy
    loss=Ldice+lamda*Lfocalloss
    :param Y_pred:A tensor resulting from a softmax(-1,z,h,w,numclass)
    :param Y_gt: A tensor of the same shape as `y_pred`
    :param gamma:Difficult sample weight
    :param alpha:Sample category weight,which is shape (C,) where C is the number of classes
    :param lamda:trade-off between dice loss and focal loss,can set 0.1,0.5,1
    :return:diceplusfocalloss
    """
    weight_loss = np.array(weight)
    smooth = 1.e-5
    smooth_tf = tf.constant(smooth, tf.float32)
    Y_pred = tf.cast(Y_pred, tf.float32)
    Y_gt = tf.cast(Y_gt, tf.float32)
    # Compute gen dice coef:
    numerator = Y_gt * Y_pred
    numerator = tf.reduce_sum(numerator, axis=(1, 2, 3))
    denominator = Y_gt + Y_pred
    denominator = tf.reduce_sum(denominator, axis=(1, 2, 3))
    gen_dice_coef = tf.reduce_sum(2. * (numerator + smooth_tf) / (denominator + smooth_tf), axis=0)
    loss1 = tf.reduce_mean(weight_loss * gen_dice_coef)
    epsilon = 1.e-5
    # scale preds so that the class probas of each sample sum to 1
    output = Y_pred / tf.reduce_sum(Y_pred, axis=- 1, keep_dims=True)
    # manual computation of crossentropy
    output = tf.clip_by_value(output, epsilon, 1. - epsilon)
    loss = -Y_gt * tf.log(output)
    loss = tf.reduce_mean(loss, axis=(1, 2, 3))
    loss = tf.reduce_mean(loss, axis=0)
    loss2 = tf.reduce_mean(weight_loss * loss)
    total_loss = (1 - lamda) * (1 - loss1) + lamda * loss2
    return total_loss


def categorical_dicePfocalloss(Y_pred, Y_gt, alpha, lamda=0.5, gamma=2.):
    """
    hybrid loss function from dice loss and focalloss
    loss=Ldice+lamda*Lfocalloss
    :param Y_pred:A tensor resulting from a softmax(-1,z,h,w,numclass)
    :param Y_gt: A tensor of the same shape as `y_pred`
    :param gamma:Difficult sample weight
    :param alpha:Sample category weight,which is shape (C,) where C is the number of classes
    :param lamda:trade-off between dice loss and focal loss,can set 0.1,0.5,1
    :return:dicePfocalloss
    """
    weight_loss = np.array(alpha)
    smooth = 1.e-5
    smooth_tf = tf.constant(smooth, tf.float32)
    Y_pred = tf.cast(Y_pred, tf.float32)
    Y_gt = tf.cast(Y_gt, tf.float32)
    # Compute gen dice coef:
    numerator = Y_gt * Y_pred
    numerator = tf.reduce_sum(numerator, axis=(1, 2, 3))
    denominator = Y_gt + Y_pred
    denominator = tf.reduce_sum(denominator, axis=(1, 2, 3))
    gen_dice_coef = tf.reduce_sum(2. * (numerator + smooth_tf) / (denominator + smooth_tf), axis=0)
    loss1 = tf.reduce_mean(weight_loss * gen_dice_coef)
    epsilon = 1.e-5
    # Scale predictions so that the class probas of each sample sum to 1
    output = Y_pred / tf.reduce_sum(Y_pred, axis=- 1, keepdims=True)
    # Clip the prediction value to prevent NaN's and Inf's
    output = tf.clip_by_value(output, epsilon, 1. - epsilon)
    # Calculate Cross Entropy
    cross_entropy = -Y_gt * tf.log(output)
    # Calculate Focal Loss
    loss = tf.pow(1 - output, gamma) * cross_entropy
    loss = tf.reduce_mean(loss, axis=(1, 2, 3))
    loss = tf.reduce_mean(loss, axis=0)
    loss2 = tf.reduce_mean(weight_loss * loss)
    total_loss = (1 - lamda) * (1 - loss1) + lamda * loss2
    return total_loss


def ssim2d_loss(Y_pred, Y_gt, maxlabel):
    """
    Computes SSIM index between Y_pred and Y_gt.only calculate 2d image,3d image can use it,but not actual ssim3d
    :param Y_pred:A tensor resulting from a softmax(-1,z,h,w,numclass)
    :param Y_gt:A tensor of the same shape as `y_pred`
    :param maxlabel:maxlabelvalue
    :return:ssim_loss
    """
    loss = tf.image.ssim(Y_pred, Y_gt, maxlabel)
    loss = tf.reduce_mean(loss)
    return loss


def multiscalessim2d_loss(Y_pred, Y_gt, maxlabel, downsampledfactor=4):
    """
    Computes the MS-SSIM between Y_pred and Y_gt.only calculate 2d image,3d image can use it,but not actual multiscalessim3d
    :param Y_pred:A tensor resulting from a softmax(-1,z,h,w,numclass)
    :param Y_gt:A tensor of the same shape as `y_pred`
    :param maxlabel:maxlabelvalue
    :param downsampledfactor:downsample factor depend on input imagesize
    :return:multiscalessim_loss
    """
    if downsampledfactor >= 5:
        _MSSSIM_WEIGHTS = (0.0448, 0.2856, 0.3001, 0.2363, 0.1333)
    if downsampledfactor == 4:
        _MSSSIM_WEIGHTS = (0.0448, 0.2856, 0.3001, 0.2363)
    if downsampledfactor == 3:
        _MSSSIM_WEIGHTS = (0.0448, 0.2856, 0.3001)
    if downsampledfactor == 2:
        _MSSSIM_WEIGHTS = (0.0448, 0.2856)
    if downsampledfactor <= 1:
        _MSSSIM_WEIGHTS = (0.0448)
    loss = tf.image.ssim_multiscale(Y_pred, Y_gt, maxlabel, power_factors=_MSSSIM_WEIGHTS)
    loss = tf.reduce_mean(loss)
    return loss