# -*- coding: utf-8 -*-
"""
This script is made to process images for Quenched-PLIF method in fluid dynamics. 
Before using it, you must have already obtained the fit values (a,b,c and d) for the inverse hyperbolic tangent.
Also, the buffers (images from DaVis* Lavision) must already be in ratio (divided).

It is better to have already done the spatial calibration, if not a special function is used to calbirated them, 
but you must at least have the mm-pixel conversion.

Finally, the script is divided into three major sections : 
    -to be continue...

Created on Thu Sep 27 15:09:17 2018

@author: Armando FEMAT ORTIZ
"""

"""
We tried to do this as cleanly as possible so that some PhD student in the future
won't get on a plane at 2:00am and come hunt us down with a crowbar.
"""


import os
import ReadIM
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import glob
from matplotlib.colors import LogNorm
from matplotlib.animation import FFMpegWriter
#from skimage.filters.rank import mean_bilateral
#from skimage.morphology import disk
#import scipy.misc

#%% Here is were we declare all the global variables that we are going to be using along the analysis and data mining

#Fitting function
a = 0.316617
b = 1.26288
c = -7.70744
d = 0.6722 

#Numerical to physical equivalences
nappe_laser = 0.250         #Thickness of laser en mm
dimension_pixel = 0.026244  #Equivalence mm/px

#Conversion to SI units
dimension_pixel_m = dimension_pixel * 10**(-3) #Equivalence m/px
nappe_laser_m = nappe_laser * 10**(-3)         #Thickness of laser en m
surface_pixel =  dimension_pixel_m**2            #Surface equivalence of a pixel (m^2)

#The working directory, where all the images are stored
working_directory = 'D:\\python_processing\\imagesV4\\XG50ppm\\'
plt.ioff()

#%% Here we present the in code functions used to make science

#Fit-inverse function 
"In is the function the user specifies a intensity ratio (can be an array) "
"the function return the value of pH associated"
def inverse_tanhfit(y):
   return (1/2*np.log((a+y-d)/(a-y+d))-c)/(b)

#Get files from folder
"In this function, the user specifies a folder "
"the function returns all the *.im7 files (DaVis) names"
def get_davis_files (folder):
    file_name = glob.glob(folder+ "\\*"+'.im7')
    return file_name

#Transform '*.im7' to array
"In this function, the user specifies the file (with extension 'C://...image.im7') *"
"the function return the image as a numpy array "
def get_image_im7 (file):
    vbuff, vatts = ReadIM.extra.get_Buffer_andAttributeList(file)
    v_array, vbuff = ReadIM.extra.buffer_as_array(vbuff)
    array = np.array(v_array[0],dtype = float)
    del(vbuff, v_array, vatts)
    return array

#Transform the ratio into pH
def ratio_ph(array):
    pH = inverse_tanhfit(array.copy())
    pH = np.nan_to_num(pH)
    return pH

#Transform the ratio into CO2 (g/m^3) concentration par pixel
def ratio_C02(array):
    co2 = inverse_tanhfit(array.copy())
    co2 = 115467070469*np.exp(-4.63*co2)                 #Concentration CO2 en g/m^3 (equal to mg/l)(numerical values)
    co2 = np.nan_to_num(co2)
    co2[co2>50] = 50
    return co2

#Transform the ratio into CO2 mass ()
def ratio_CO2mass(array,r):
    co2 = inverse_tanhfit(array.copy())
    co2 = 115467070469*np.exp(-4.63*co2)                 #Concentration CO2 en g/m^3 (equal to mg/l)(numerical values)
    co2 = np.nan_to_num(co2)
    co2[co2>50] = 50
    co2 = centre(co2)
    co2 = get_half_meanarray(co2)
    co2 = (co2) @ r  
    return (surface_pixel * np.pi * 2 * co2.sum())/nappe_laser_m

#Get the radius for the calculation of CO2 Mass
def get_radius(array):
    r = []
    radius  = dimension_pixel_m            
    for k in range(len(array[0])//2):
        r.append(radius)
        radius += dimension_pixel_m
        
    r = np.flipud(r)            
    return r

#Get the half mean array to apply the axisymetrie to the array.
def get_half_meanarray(array):
    cut_image1 = array[0:len(array),0:len(array[0])//2]
    cut_image2 = array[0:len(array),len(array[0])//2:len(array[0])]
    cut_image2 = np.fliplr(cut_image2[0:len(cut_image1),0:len(cut_image1[0])])
    return np.mean(np.array([cut_image1,cut_image2]), axis=0,dtype=np.float64)


#This function count the zeros until the first value 
def count_zeroes(array):
    return (array.cumsum(axis=1) == 0).sum(axis=1)

#This function centers all the values 
def centre(array):
    zeroes_front = count_zeroes(array)
    zeroes_back = count_zeroes(array[:,::-1])
    roll = (zeroes_front + zeroes_back) //2 - zeroes_front
    return np.array([np.roll(row, r) for row, r in zip(array, roll)])

'Needs developement for image creation and video'
#
def image(array):
    
    return

#
def video(video_array):
    
    return


#%%

files = get_davis_files(working_directory)
get_rayon = True
mass = []
for i in range(len(files)):
    array = get_image_im7(files[i])
    if get_rayon:
        r = get_radius(array)
        get_rayon = False
        
    mass.append(ratio_CO2mass(array,r))
    
del(get_rayon,r)