kincom.rb

#KinCom
require 'roo'

$debug = false

class Kincom

def nms(kick, time)

object = instance_variable_get(:@kicks_ms_dif_nms)
  
  if time == 30
    value = 0

  elsif time == 50
    value = 1

  elsif time == 100
    value = 2

  elsif time == 200
    value = 3

  else
    return "Vælg mellem 30, 50, 100 eller 200."
  end

return object[kick[value]]

end

def percentage(kick)
length = self.instance_variable_get(:@kicks_ms_dif_nmpc).length

if kick == "all"
  return instance_variable_get(:@kicks_ms_dif_nmpc)
elsif kick == [1..length]
  return instance_variable_get(:@kicks_ms_dif_nmpc)[kick-1]
else
  return "Kick number \'" + kick.to_s + "\' doesn't exist."
end
end

def nm(kick)
length = self.instance_variable_get(:@kicks_ms_dif_nm).length

if kick == "all"
  return instance_variable_get(:@kicks_ms_dif_nm)
elsif kick == [1..length]
  return instance_variable_get(:@kicks_ms_dif_nm)[kick-1]
else
  return "Kick number \'" + kick.to_s + "\' doesn't exist."
end
end

def n(kick)

length = self.instance_variable_get(:@kicks_ms_dif_n).length

if kick == "all"
  return instance_variable_get(:@kicks_ms_dif_n)
elsif kick == [1..length]
  return instance_variable_get(:@kicks_ms_dif_n)[kick-1]
else
  return "Kick number \'" + kick.to_s + "\' doesn't exist."
end
end

def msdif(kick)

length = self.instance_variable_get(:@kicks_ms_dif).length

if kick == "all"
  return instance_variable_get(:@kicks_ms_dif)
elsif kick == [1..length]
  return instance_variable_get(:@kicks_ms_dif)[kick-1]
else
  return "Kick number \'" + kick.to_s + "\' doesn't exist."
end
end

def ms(kick)

length = self.instance_variable_get(:@kicks_ms).length

if kick == "all"
  return instance_variable_get(:@kicks_ms)
elsif kick == [1..length]
  return instance_variable_get(:@kicks_ms)[kick-1]
else
  return "Kick number \'" + kick.to_s + "\' doesn't exist."
end
end

def mvc(kicktype)	

if kicktype == "left"
instance_variable_get(:@mvc_left)

elsif kicktype == "right"
instance_variable_get(:@mvc_right)

else
return "MVC for the passed kicktype doesn't exist. Accepts only left or right"
end

end

def maxMVC(kicktype)

if kicktype.to_s.match('\bleft\b') or kicktype.to_s.match('\bright\b')
  mvc(kicktype).max
else
  return kicktype + " is not a kick type. Must be 'left' or 'right'."
end

end

## Håndterer load af data
def load(filename)
#Åbner dokumentet
@xlsx = Roo::Spreadsheet.open(filename)
return @xlsx.sheets
end

## Håndterer udregninger. Returnerer et array af forskellige værdi-grupper. Alle disse værdi-grupper indeholder hver et array af værdier for hvert spark
def calculate(array, arm, stopIndex, procent)

array.each do |a|
volt_raw = @xlsx.sheet(a).column(2)
  if positive?(volt_raw) == true
    if $debug == true
    puts a + " er positivt"
    end
    kicktype = "højre"
    #Normaliserer array, så der ingen negative værdier er.
    volt = normalizePositive(volt_raw)	

  elsif positive?(volt_raw) == false
    if $debug == true
    puts a + " er negativt"
    end
    kicktype = "venstre"
    #Normaliserer array, så der ingen negative værdier er.
    volt = normalizeNegative(volt_raw)	

  else
  return "Something is wrong here."
  end
    
  #Finder baseline
  baseline = baseline(volt)
  if $debug == true
  puts a + "'s Baseline: " + baseline.round(2).to_s
  end
  #Finder det korrigerede MVC
  mvc = calcMvc(volt, baseline)
  if $debug == true
  puts a + "'s Korrigerede MVC: " + mvc.round(2).to_s
  end

  #Tager opgivet procent (normalt 2,5%) og finder den værdi en måling i sparket skal være, for at kategoriseres som en del af sparket (og ikke støj)
  percentage = baseline + (mvc * procent)
  if $debug == true
  puts "Procent: " + percentage.round(4).to_s
  end		
  #Duplikerer arrayet, så der er et nyt at arbejde med (således, at man kan sammenligne begge arrays visuelt)
  kick_array = volt.dup
  
  #Udregningsfunktion. Returnerer ms_array, ms_dif_array, ms_dif_n_array, ms_dif_nm_array, ms_dif_nmpc_array som arrays i et array
  calculation = rfdCalculation(kick_array, arm, mvc, stopIndex/100.to_f, percentage)
  ms_array = calculation[0]
  ms_dif_array = calculation[1]
  ms_dif_n_array = calculation[2]
  ms_dif_nm_array = calculation[3]
  ms_dif_nms_array = calculation[4]
  ms_dif_nmpc_array = calculation[5]
  
  #Pusher de forskellige værdier pr. spark ind i et array for alle forsøgspersonens spark
  output = output(mvc, ms_array, ms_dif_array, ms_dif_n_array, ms_dif_nm_array, ms_dif_nms_array, ms_dif_nmpc_array, kicktype)
      
end

end

def output(mvc, ms, msdif, msdif_n, msdif_nm, msdif_nms, msdif_nmpc, kicktype)

  if @kicks_ms == nil
    @kicks_ms = Array.new
    @kicks_ms_dif = Array.new
    @kicks_ms_dif_n = Array.new
    @kicks_ms_dif_nm = Array.new
    @kicks_ms_dif_nms = Array.new
    @kicks_ms_dif_nmpc = Array.new
        
    @mvc_right = Array.new
    @mvc_left = Array.new
  end
  
  @kicks_ms.push(ms)
  @kicks_ms_dif.push(msdif)
  @kicks_ms_dif_n.push(msdif_n)
  @kicks_ms_dif_nm.push(msdif_nm)
  @kicks_ms_dif_nms.push(msdif_nms)
  @kicks_ms_dif_nmpc.push(msdif_nmpc)
  
  if kicktype == "højre"
    @mvc_right.push(mvc)
  elsif kicktype == "venstre"
    @mvc_left.push(mvc)
  else
    return "Sparket kan ikke identificeres"
    
  end
  
end

def positive?(array)
  if array.inject(:+).quo(array.size) > 0
    return true
  else
    return false
  end
end

def normalizePositive(array)
  #Vender array om
  array.reverse!
  #Fjerner den første tredjedel af arrayet (for at fjerne det sidste af sparket)
  volt_pos = array.drop(array.length/3)
  #Vender arrayet om igen
  volt_pos.reverse!
  #Lægger minimum-værdien til arrayet, så grafen kommer over 0. (Eliminerer alle negative tal) og returnerer
  return volt_pos.map! {|x| x + array.min.abs}
  
end

def normalizeNegative(array)
  #Vender array om
  array.reverse!
  #Fjerner den første tredjedel af arrayet (for at fjerne det sidste af sparket)
  volt_neg = array.drop(array.length/3)
  #Vender arrayet om igen
  volt_neg.reverse!
  #Tryller
  return volt_neg.map! {|x| (x - array.max.abs)*-1}
end

def baseline(array)
  #Laver en baseline ud fra de første 100 elementer af array
  baseline = Array.new(array.first(100))
  #Returnerer et gennemsnit af de 100 elementer
  return baseline.inject(:+).quo(baseline.size)
end

def calcMvc(array, baseline)
  mvc = array.max
  return mvc - baseline
end

def rfdCalculation(array, arm, mvc, stop_index, procent)

  newton_mvc = (mvc*1000)/4.88
  
  if $debug == true
    puts newton_mvc.round(4).to_s
  end
  
  nm_mvc = newton_mvc*arm
  
  if $debug == true
    puts nm_mvc.round(4).to_s
    puts "Stop index: "+stop_index.to_s
    puts "Procent-værdi: " + procent.to_s
  end
  #Finder værdi til ms 0
  ms0 = rfdArray(array, 0, stop_index, procent)
  ms30 = rfdArray(array, 30, stop_index, procent)
  ms50 = rfdArray(array, 50, stop_index, procent)
  ms100 = rfdArray(array, 100, stop_index, procent)
  ms200 = rfdArray(array, 200, stop_index, procent)
  
  ms_array = Array.new
  ms_array.push(ms0, ms30, ms50, ms100, ms200)

  if $debug == true
    puts "MS0: " + ms0.round(2).to_s + ", MS30: " + ms30.round(2).to_s + ", MS50: " + ms50.round(2).to_s + ", MS100: " + ms100.round(2).to_s + ", MS200: " + ms200.round(2).to_s
  end

  ms0_30 = ms30 - ms0
  ms0_50 = ms50 - ms0
  ms0_100 = ms100 - ms0
  ms0_200 = ms200 - ms0

  ms_dif_array = Array.new
  ms_dif_array.push(ms0_30, ms0_50, ms0_100, ms0_200)
  
  if $debug == true
    puts "MS0-30: " + ms0_30.round(2).to_s + ", MS0-50: " + ms0_50.round(2).to_s + ", MS0-100: " + ms0_100.round(2).to_s + ", MS0-200: " + ms0_200.round(2).to_s
  end
  
  ms0_30n = (ms0_30 * 1000) / 4.88
  ms0_50n = (ms0_50 * 1000) / 4.88
  ms0_100n = (ms0_100 * 1000) / 4.88
  ms0_200n = (ms0_200 * 1000) / 4.88

  ms_dif_n_array = Array.new
  ms_dif_n_array.push(ms0_30n, ms0_50n, ms0_100n, ms0_200n)
  
  if $debug == true
    puts "MS0-30n: " + ms0_30n.round(2).to_s + ", MS0-50n: " + ms0_50n.round(2).to_s + ", MS0-100n: " + ms0_100n.round(2).to_s + ", MS0-200n: " + ms0_200n.round(2).to_s
  end
  
  ms0_30nm = ms0_30n * arm
  ms0_50nm = ms0_50n * arm
  ms0_100nm = ms0_100n * arm
  ms0_200nm = ms0_200n * arm
  
  ms_dif_nm_array = Array.new
  ms_dif_nm_array.push(ms0_30nm, ms0_50nm, ms0_100nm, ms0_200nm)
  
  if $debug == true
    puts "MS0-30nm: " + ms0_30nm.round(2).to_s + ", MS0-50nm: " + ms0_50nm.round(2).to_s + ", MS0-100nm: " + ms0_100nm.round(2).to_s + ", MS0-200nm: " + ms0_200nm.round(2).to_s
  end
  
  ms0_30nms = ms0_30nm / 0.03
  ms0_50nms = ms0_50nm / 0.05
  ms0_100nms = ms0_100nm / 0.1
  ms0_200nms = ms0_200nm / 0.2
  
  ms_dif_nms_array = Array.new
  ms_dif_nms_array.push(ms0_30nms, ms0_50nms, ms0_100nms, ms0_200nms)
  
  if $debug == true
    puts "MS0-30nm/s: " + ms0_30nms.round(2).to_s + ", MS0-50nm/s: " + ms0_50nms.round(2).to_s + ", MS0-100nm/s: " + ms0_100nms.round(2).to_s + ", MS0-200nm/s: " + ms0_200nms.round(2).to_s
  end
  
  ms0_30nmpc = (ms0_30nm/nm_mvc)* 100
  ms0_50nmpc = (ms0_50nm/nm_mvc)* 100
  ms0_100nmpc = (ms0_100nm/nm_mvc)* 100
  ms0_200nmpc = (ms0_200nm/nm_mvc) * 100

  ms_dif_nmpc_array = Array.new
  ms_dif_nmpc_array.push(ms0_30nmpc, ms0_50nmpc, ms0_100nmpc, ms0_200nmpc)

  if $debug == true
    puts "MS0-30nm procent af MVC: " + ms0_30nmpc.round(2).to_s + "%, MS0-50n procent af MVC: " + ms0_50nmpc.round(2).to_s + "%, MS0-100n procent af MVC: " + ms0_100nmpc.round(2).to_s + "%, MS0-200n procent af MVC: " + ms0_200nmpc.round(2).to_s + "%"
  end
  
  return ms_array, ms_dif_array, ms_dif_n_array, ms_dif_nm_array, ms_dif_nms_array, ms_dif_nmpc_array
  
end

  def rfdArray(array, t, stop_index, procent)
  
  #Definerer ved hvilken længde array'et skal cuttes af. Det er nødvendigt for at der kun kigges på starten af sparket.
  stop = array.length*stop_index
  array.reject!.each_with_index{|v, i| break if i >= stop; v < procent}

  return array.fetch(t, 'Nothing on this position')
  end

##Håndterer skrivelsen til "Databasen", som er et excel-ark

def writeToDB(filename, fp, right, left)
openDB(filename)
findRowDB(@sheet)
writeDB(@index, fp, right, left)
end

#Åbner excelarket
def openDB(filename)
  @book = RubyXL::Parser.parse(filename)

  @sheet = @book[0]
  row = @sheet[0]
end 

#Finder ud hvilken Row der returnerer nil og dermed kan skrives til
def findRowDB(sheet)
  i = 0
  j = 0
    while j != nil do
    j = sheet[i]
    i += 1
    end

  @index = i-1
end

#Skriver til excel-arket
def writeDB(row, fp, right, left)

  #ID-kolonne
  @sheet.add_cell(row, 0, fp)
  #Right-kolonne
  @sheet.add_cell(row, 1, right)
  #Left-kolonne
  @sheet.add_cell(row, 2, left)
  
  @book.write(@filename)
end

private :output, :positive?, :normalizePositive, :normalizeNegative, :baseline, :calcMvc, :rfdCalculation, :rfdArray, :openDB, :findRowDB, :writeDB

end