Added new version to calculate state

main.R

@@ -1,17 +1,18 @@
-library(dplyr)
-
+suppressMessages(library(dplyr))
 
 WD <- getwd()
 
+specify_decimal <- function(x, k) format(round(x, k), nsmall=k)
 
 CSV <- file.choose()
 
 CSV <- read.csv(CSV)
 
 # CONVERT
-converted_ <- NULL
+DATA <- NULL
 
 for(i in 1:(nrow(CSV) / 3)) {
+  #if(i < 215 || i > 240) next
   x <- NULL
   y <- NULL
   z <- NULL
@@ -27,23 +28,157 @@ for(i in 1:(nrow(CSV) / 3)) {
 
   if(i == 1) {
     #print("CREATE")
-    converted_ <- cnv_
+    DATA <- cnv_
   }
   else {
     #print("BIND")
-    converted_ <- bind_rows(converted_, cnv_)
+    DATA <- bind_rows(DATA, cnv_)
   }
 
 }
 
-plot(converted_$Head.y,
+DATA$state = "UNKNOWN"
+
+remove(x)
+remove(y)
+remove(z)
+remove(cnv_)
+
+headDF <- select(DATA, Time, Head.y)
+headDF$IndexTime <- 1:nrow(headDF)
+lowpoints <- subset(headDF, headDF$Head.y <= 0.0)
+lowpoints <- diff(as.matrix(lowpoints))
+lowpoints <- as.data.frame(lowpoints)
+
+calcIndexTime <- max(lowpoints$IndexTime)
+
+#GET SMALLEST VALUE OF HEAD HIGHT
+
+# GRAPH IS ALWAYS => SITTING, GET_UP, WALKING, GET_DOWN, SITTING
+
+min_ <- min(DATA$Head.y)
+norm_ <- 0
+
+sitting1 <- c()
+get_up <- c()
+walking <- c()
+get_down <- c()
+sitting2 <- c()
+
+cur_state  <- ""
+cur_count  <- 0
+prev_state <- ""
+prev_count <- 0
+deep_state <- ""
+deep_count <- 0
+
+row_count <- 0
+
+plot(DATA$Head.y,
      type = "l",
      ylab = "Hoogte hoofd"
-     )
+)
 
+for(i in 2:nrow(DATA)){
+  offset <- DATA[i-1,]
 
+  diff = offset$Head.y - DATA[i,]$Head.y
 
+  color <- "black"
 
+  if(diff < -0.013){
+    DATA[i,]$state = "GET_UP"
+    color <- "red"
+  }
+  else if(diff > 0.013){
+    DATA[i,]$state = "GET_DOWN"
+    color <- "red"
+  }
+  else if(DATA[i,]$Head.y - min_ > 0.15){
+    DATA[i,]$state = "WALKING"
+    color <- "blue"
+  }
+  else{
+    DATA[i,]$state = "SITTING"
+    color <- "green"
+  }
 
+  prox <- 8
+
+  if(cur_state == DATA[i,]$state && i != nrow(DATA)){
+    cur_count <- cur_count+1
+    row_count <- row_count+1
+    if(cur_count > prox){
+      prev_state <- cur_state
+      prev_count <- cur_count
+      deep_count <- 0
+      deep_state <- cur_state
+    }
+  }
+  else if(DATA[i,]$state == deep_state){
+    cur_state <- DATA[i,]$state
+    #cur_count <- deep_count+1
+  }
+  else if(i == nrow(DATA)){
+    sitting2 <- c(i-deep_count, i-1)
+  }
+  else{
+    if(prev_count == row_count){
+      cur_count <- cur_count+1
+    }
+    else if(deep_state == "WALKING" && row_count > 3){
+      cur_count <- cur_count+2
+    }
+    else if(deep_state == ""){
+      deep_state = DATA[i,]$state
+    }
+    else if(cur_count < prox){
+      cur_count <- cur_count+1
+    }
+    else if(prev_count <= prox){
+      deep_count <- deep_count + 1
+      prev_state <- deep_state
+      prev_count <- deep_count
+      cur_state <- prev_state
+      cur_count <- cur_count+1
+    }
+    else if (prev_count > prox ){
+      deep_count <- cur_count + 1
+      #deep_state <- prev_state
+      vct <- c(i-deep_count, i-1)
+      points(i-deep_count, 0, col = "black")
+      if(deep_state == "SITTING" && i < nrow(DATA) / 2){
+        sitting1 <- vct
+      }
+      else if(deep_state == "SITTING"){
+        sitting2 <- vct
+      }
+      else if(deep_state == "GET_UP"){
+        get_up <- vct
+      }
+      else if(deep_state == "WALKING"){
+        walking <- c(walking, vct)
+      }
+      else if(deep_state == "GET_DOWN"){
+        get_down <- vct
+      }
+      #print(deep_state)
+      #print(vct)
+
+      deep_count <- 0
+      #deep_state <- ""
+      #prev_count <- 0
+
+      cur_count <- 1
+      prev_count <- 1
+      row_count <- 1
+      cur_state <- DATA[i,]$state
+
+    }
+    cur_state <- DATA[i,]$state
+    row_count <- 1
+  }
+  points(i, DATA[i,]$Head.y, col = color)
+}
 
 

mainV2.R

@@ -0,0 +1,118 @@
+suppressMessages(library(dplyr))
+suppressMessages(library(stringr))
+
+WD <- getwd()
+
+specify_decimal <- function(x, k) format(round(x, k), nsmall=k)
+
+CSV <- file.choose()
+
+CSV <- read.csv(CSV)
+
+# CONVERT
+DATA <- NULL
+
+for(i in 1:(nrow(CSV) / 3)) {
+  x <- NULL
+  y <- NULL
+  z <- NULL
+
+  if(i > 1) { i <- i * 3 - 2 }
+
+  x <- CSV[i,]
+  y <- CSV[i+1,]
+  z <- CSV[i+2,]
+
+  cnv_ <- merge(x, y, all = TRUE, suffixes = c(".x", ".y"), by = "Time")
+  cnv_ <- merge(cnv_, z, all = TRUE, suffixes = c("", ".z"), by = "Time")
+
+  if(i == 1) {
+    DATA <- cnv_
+  }
+  else {
+    DATA <- bind_rows(DATA, cnv_)
+  }
+
+}
+
+DATA$state = "UNKNOWN"
+
+remove(x)
+remove(y)
+remove(z)
+remove(cnv_)
+
+#Plot graph
+plot(DATA$Head.y,
+     type = "l",
+     ylab = "Hoogte hoofd"
+)
+
+# CALCULATE PATIENT STATE ALGORITHM
+STATE = c("WALK", "UP", "DOWN", "SIT")
+size_ <- 5
+differ_ <- 0.1
+  #color <- rainbow(length(STATE))
+color <- c("red", "blue", "blue", "green")
+
+POINTS <- data.frame(
+  index = integer(1)
+)
+POINTS["state"] <- 0
+
+for(i in 1:size_){
+  POINTS[LETTERS[i]] <- 0
+}
+
+for(i in size_:(nrow(DATA)-size_)){
+  start <- DATA[i,]$Head.y
+  end <- DATA[i+size_,]$Head.y
+
+  state_ <- NULL
+
+  if(((start - end) < differ_) && (start - end) > -differ_){
+    if(start >= mean(DATA$Head.y)){ #WALK (4)
+      state_ <- 1
+    }
+    else{ #SIT (4)
+      state_ <- 4
+    }
+  }
+  else if((start - end) < differ_) { #UP (2)
+    state_ <- 2
+  }
+  else if((start - end) > differ_) { #UP (3)
+    state_ <- 3
+  }
+  else {
+    state_ <- 1
+  }
+
+  for(j in 0:size_-1){
+    POINTS[i-j,LETTERS[j+1]] <- state_
+    #POINTS[i,LETTERS[j+1]] <- state_
+  }
+
+  if(i>size_*2 && i<=((nrow(DATA) - size_)+1)){
+    POINTS[i-size_,]$state <- (
+      tbl_df(
+        table(
+          POINTS[i-size_,] %>%
+            unlist(., use.names=FALSE)
+          )
+        ) %>%
+        arrange(
+          desc(n)
+          )
+      )[1,]$Var1
+  }
+  #Plot state point on graph
+  points(i, DATA[i,]$Head.y, col = color[state_])
+
+}
+
+
+
+
+
+