KdJametPython/class_KdJamet.py

#!/usr/bin/python
# -*- coding: utf-8 -*-

import numpy as np
import sys
import os

Sensor = {'idSEAWIFS' = 0, 'idMODIS' = 1, 'idMERIS' = 2}

class Kd_Jamet:
  def __init__(self, idSensor):
    try:
      self.lutpath = os.getenv('KD_LUT_PATH')
    except:
      print "KD_LUT_PATH not set, add it to your environement variables"
      sys.exit()
      
    if Sensor.has_key(idSensor):
      self.init_variables(Sensor[idSensor])
      try:
        self.read_LUTs_Kd(Sensor[idSensor])
      except:
        print "Failed to read %s LUTs" % (idSensor)
        sys.exit()
  
  # -
  # Perceptron parameters setting and array initialization for each Sensor
  # -
  def init_variables(self, idSensor):
    # =======================================================================================================
    # MERIS / OLCI 
    # =======================================================================================================
    if idSensor == Sensor['idMERIS']:
      # Variables definiton for network Rrs490/Rrs555 >= .85 -------------------------------------------------
      # hidden layer number 
      self.rsup_NC 2
      # input data number
      self.rsup_NE 5
      # number of neuron in the first hidden layer 
      self.rsup_NC1 7
      # number of neuron in the second hidden layer
      self.rsup_NC2 4
      # nb output
      self.rsup_NS 1
      # nb input + nb output*/
      self.rsup_NES 6
      # LUTs file names 
      self.rsup_LUT_POIDS "KdOLCI_poids_IOCCG_NOMAD_BOUM_ss_12_COASTCOLOUR_443_to_555_log_Kd_lambda_merge_seuil_15_angle_ascii_6x1_hh_7_4_switch_110416.sn"
      self.rsupLUT_MOY "Moy_KdOLCI_IOCCG_NOMAD_BOUM_ss_12_COASTCOLOUR_412_to_670_log_Kd_lambda_merge_seuil_15_angle_publi_ss_620.dat"
      self.rsup_LUT_ECART "Ecart_KdOLCI_IOCCG_NOMAD_BOUM_ss_12_COASTCOLOUR_412_to_670_log_Kd_lambda_merge_seuil_15_angle_publi_ss_620.dat"

      # Variables definiton for network Variables definiton for network < .85 -----------------------------------
      # nombre de couches cachees - hidden layer number
      self.rinf_NC 2
      # input data number*/
      self.rinf_NE 6
      # number of neuron in the first hidden layer
      self.rinf_NC1 5
      # number of neuron in the second hidden layer
      self.rinf_NC2 5
      # nb output
      self.rinf_NS 1
      # nb input + nb output
      self.rinf_NES 7
      #LUTs file names
      self.rinf_LUT_POIDS "KdOLCI_poids_IOCCG_NOMAD_BOUM_ss_12_COASTCOLOUR_443_to_670_log_Kd_lambda_merge_seuil_15_angle_ascii_6x1_hh_5_5_switch_110416.sn"
      self.rinf_LUT_MOY "Moy_KdOLCI_IOCCG_NOMAD_BOUM_ss_12_COASTCOLOUR_412_to_670_log_Kd_lambda_merge_seuil_15_angle_publi_ss_620.dat"
      self.rinf_LUT_ECART "Ecart_KdOLCI_IOCCG_NOMAD_BOUM_ss_12_COASTCOLOUR_412_to_670_log_Kd_lambda_merge_seuil_15_angle_publi_ss_620.dat"

    #LUTs arrays definition
    self.rsup_b1 = np.zeros((rsup_NC1), dtype=np.float32) 
    self.rsup_b2 = np.zeros((rsup_NC2), dtype=np.float32) 
    self.rsup_b3 = 0.
    self.rsup_w1 = np.zeros((rsup_NE,rsup_NC1), dtype=np.float32)
    self.rsup_w2 = np.zeros((rsup_NC1,rsup_NC2), dtype=np.float32)
    self.rsup_w3 = np.zeros((rsup_NC2), dtype=np.float32)
    self.rsup_moy = np.zeros((rsup_NES), dtype=np.float32)
    self.rsup_ecart = np.zeros((rsup_NES), dtype=np.float32)

    self.rinf_b1 = np.zeros((rinf_NC1), dtype=np.float32)
    self.rinf_b2 = np.zeros((rinf_NC2), dtype=np.float32)
    self.rinf_b3 = 0.
    self.rinf_w1 = np.zeros((rinf_NE,rinf_NC1), dtype=np.float32)
    self.rinf_w2 = np.zeros((rinf_NC1,rinf_NC2), dtype=np.float32)
    self.rinf_w3 = np.zeros((rinf_NC2), dtype=np.float32)
    self.rinf_moy = np.zeros((rinf_NES), dtype=np.float32)
    self.rinf_ecart = np.zeros((rinf_NES), dtype=np.float32)
  
  # -
  # perceptron weights LUT reading
  # -
  def read_LUTs_Kd(self):
    # ----------------------------------------------------------------------------------
    #  < .85 weights settings
    weights = numpy.loadtxt( "%s/%s" % (self.lutpath, self.rinf_LUT_POIDS), skiprows=1)
    base = 0
    self.rinf_b1 = weights[base:base+self.rinf_NC1,2]
    base = base+self.rinf_NC1
    self.rsup_b2 = weights[base:base+self.rinf_NC2,2]
    base = base+self.rinf_NC2
    self.rsup_b3 = weights[base:base+self.rinf_NS,2]
    base = base+self.rinf_NS
    for i in range(self.rinf_NE):
      self.rinf_w1[i,:] = weights[base:base+self.rinf_NC1,2]
      base = base+self.rinf_NC1
    for i in range(self.rinf_NC1):
      self.rinf_w2[i,:] = weights[base:base+self.rinf_NC2,2]
      base = base+self.rinf_NC2
    self.rinf_w3 = weights[base:base+self.rinf_NC3,2]
    
    usedData = np.array([1,2,3,4,5,6,8])
    if idSensor == Sensor['idMODIS']:
      usedData = np.array([1,2,3,4,6,7,9])
    moy = numpy.loadtxt( "%s/%s" % (self.lutpath, self.rinf_LUT_MOY))
    self.rinf_moy = moy[usedData]
    ecart = numpy.loadtxt( "%s/%s" % (self.lutpath, self.rinf_LUT_ECART))
    self.rinf_ecart = ecart[usedData]
    
    # ----------------------------------------------------------------------------------
    #  >= .85 weights settings
    weights = numpy.loadtxt( "%s/%s" % (self.lutpath, self.rsup_LUT_POIDS), skiprows=1)
    base = 0
    self.rsup_b1 = weights[base:base+self.rsup_NC1,2]
    base = base+self.rsup_NC1
    self.rsup_b2 = weights[base:base+self.rsup_NC2,2]
    base = base+self.rsup_NC2
    self.rsup_b3 = weights[base:base+self.rsup_NS,2]
    base = base+self.rsup_NS
    for i in range(self.rsup_NE):
      self.rsup_w1[i,:] = weights[base:base+self.rsup_NC1,2]
      base = base+self.rsup_NC1
    for i in range(self.rsup_NC1):
      self.rsup_w2[i,:] = weights[base:base+self.rsup_NC2,2]
      base = base+self.rsup_NC2
    self.rsup_w3 = weights[base:base+self.rsup_NC3,2]
    
    usedData = np.array([1,2,3,4,6,8])
    if idSensor == Sensor['idMODIS']:
      usedData = np.array([1,2,3,4,7,9])
    moy = numpy.loadtxt( "%s/%s" % (self.lutpath, self.rsup_LUT_MOY))
    self.rsup_moy = moy[usedData]
    ecart = numpy.loadtxt( "%s/%s" % (self.lutpath, self.rsup_LUT_ECART))
    self.rsup_ecart = ecart[usedData]
    
  # -
  # Kd computing   < .85
  # input = nRrs + output Lambda
  # -
  def passe_avant_sup(self, indata):
    # Normalization
    x = ((2/3.) * indata[:] - self.rsup_moy[:]) / self.rsup_ecart[:]
    
    a = np.zeros(self.rsup_NC1,dtype=np.float32)
    for i in range(self.rsup_NC1):
      for j in range(self.rsup_NE):
        a[i] = a[i] + x[j] * self.rsup_w1[j][i]
    a[:] = 1.715905*np.tanh((2./3.)*(a[:] + self.rsupSW_b1[:]))

    b = np.zeros[self.rsup_NC2,dtype=np.float32]
    for i in range(self.rsup_NC2):
      for j in range(self.rsup_NC1):
        b[i] = b[i] + a[j] * self.rsup_w2[j][i]
    b[:] = 1.715905*np.tanh((2./3.)*(b[:] + self.rsupSW_b2[:]))
    
    y = np.sum(b[:] * self.rsupSW_w3[:])
    # Denormalisation 
    y = 1.5*(y + self.rsupSW_b3)*self.rsupSW_ecart[self.rsupSW_NES-1] + self.rsupSW_moy[self.rsupSW_NES-1]
    y = 10.**y
    return(y)
  
  # -
  # Kd computing  >= .85 
  # input = nRrs + output Lambda
  # -
  def passe_avant_inf(self, indata):
    # Normalization
    x = ((2/3.) * indata[:] - self.rinf_moy[:]) / self.rinf_ecart[:]
    
    a = np.zeros(self.rinf_NC1,dtype=np.float32)
    for i in range(self.rinf_NC1):
      for j in range(self.rinf_NE):
        a[i] = a[i] + x[j] * self.rinf_w1[j][i]
    a[:] = 1.715905*np.tanh((2./3.)*(a[:] + self.rinfSW_b1[:]))

    b = np.zeros[self.rinf_NC2,dtype=np.float32]
    for i in range(self.rinf_NC2):
      for j in range(self.rinf_NC1):
        b[i] = b[i] + a[j] * self.rinf_w2[j][i]
    b[:] = 1.715905*np.tanh((2./3.)*(b[:] + self.rinfSW_b2[:]))
    
    y = np.sum(b[:] * self.rinfSW_w3[:])
    # Denormalisation 
    y = 1.5*(y + self.rinfSW_b3)*self.rinfSW_ecart[self.rinfSW_NES-1] + self.rinfSW_moy[self.rinfSW_NES-1]
    y = 10.**y
    return(y)