1. # data schema
2.  
3. periods = list()
4. periods[[1]] = c(0, 120)
5. periods[[2]] = c(120, 300)
6. periods[[3]] = c(300, 480)
7. periods[[4]] = c(480, 660)
8. periods[[5]] = c(660, 840)
9. periods[[6]] = c(840, 1020)
10. periods[[7]] = c(1020, 1200)
11. periods[[8]] = c(1200, 1380)
12. periods[[9]] = c(1200, 1380)
13. periods[[10]] = c(1380, 1560)
14. periods[[11]] = c(1560, 1740)
15.  
16. actionNames <- c("dynamic_lever_pressing", "cage_exploring", "lying_down", "grooming", "laser", "freezing", "akinesia", "slow_lever_pressing", "presence_next_to_feeder", "scratching", "chewing", "yawning")
17.  
18. # utility functions
19.  
20. decorateAction <- function(action) {
21.   trimmedAction = trimws(action)
22.   if(trimmedAction == "time_on_lever_pressing_exploredisspan") {
23.     return(actionNames[1])
24.   } else if (trimmedAction == "time_on_exploring_cage") {
25.     return(actionNames[2])
26.   } else if (trimmedAction == "nap") {
27.     return(actionNames[3])
28.   } else if (trimmedAction == "grooming") {
29.     return(actionNames[4])
30.   } else if (trimmedAction == "laser") {
31.     return(actionNames[5])
32.   } else if (trimmedAction == "freezing") {
33.     return(actionNames[6])
34.   } else if (trimmedAction == "catatonic") {
35.     return(actionNames[7])
36.   } else if (trimmedAction == "slowly_lever_presing") {
37.     return(actionNames[8])
38.   } else if (trimmedAction == "exloring_and_time_disspa") {
39.     return(actionNames[9])
40.   } else if (trimmedAction == "scratching") {
41.     return(actionNames[10])
42.   } else if (trimmedAction == "zucie") {
43.     return(actionNames[11])
44.   } else if (trimmedAction == "ziewanie") {
45.     return(actionNames[12])
46.   } else {
47.     print(action)
48.   }
49. }
50.  
51. decoratePeriod <- function(period) {
52.   return(paste(period[1], "_", period[2], sep = ""))
53. }
54.  
55. indexNameForPeriod <- function(period) {
56.   return(paste(period[1], "-", period[2], sep = ""))
57. }
58.  
59. map <- function(collection, fun) {
60.   res <- list()
61.   counter <- 1
62.   for (methods/html/el.html">el in collection) {
63.     res[[counter]] <- fun(methods/html/el.html">el)
64.     counter <- counter+1
65.   }
66.   return(res)
67. }
68.  
69. select <- function(collection, fun) {
70.   res <- list()
71.   counter <- 1
72.   for (methods/html/el.html">el in collection) {
73.     if (fun(methods/html/el.html">el)) {
74.       res[[counter]] <- methods/html/el.html">el
75.       counter <- counter+1
76.     }
77.   }
78.   return(res)
79. }
80.  
81. sum <- function(collection, attr) {
82.   amount <- 0
83.   for (methods/html/el.html">el in collection) {
84.     amount <- amount + methods/html/el.html">el[[attr]]
85.   }
86.   amount
87. }
88.  
89. generateVectorFromCollection <- function(collection) {
90.   vec <- c()
91.   for (methods/html/el.html">el in collection) {
92.     vec <- c(vec, methods/html/el.html">el)
93.   }
94.   return(vec)
95. }
96.  
97. # business logic
98.  
99. getTimeRowsFromFile <- function(filename) {
100.   lines <- readLines(filename)
101.   return(lines[2:length(lines)])
102. }
103.  
104. timeStrToSeconds <- function(str) {
105.   numbers <- strsplit(str, ":")[[1]]
106.   amount = (as.numeric(numbers[1]) * 3600) + (as.numeric(numbers[2]) * 60) + as.numeric(numbers[3]) + (as.numeric(numbers[4]) / 100)
107.   return(amount)
108. }
109.  
110. parseRow <- function(row) {
111.   res <- list()
112.   parts <- strsplit(row, " - ")[[1]]
113.   res[["time_in_sec"]] <- timeStrToSeconds(parts[1])
114.   res[["action"]] <- parts[2]
115.   return(res)
116. }
117.  
118. getActionPairsFromFile <- function(filename) {
119.   parsedRows <- map(getTimeRowsFromFile(filename), function(row) { return(parseRow(row)) })
120.   startTimeInSeconds <- parsedRows[[1]][["time_in_sec"]]
121.   rowActionsCache <- list()
122.   result <- list()
123.   counter <- 1
124.   for(row in parsedRows[2:(length(parsedRows)-1)]) {
125.     calculatedTime <- row[["time_in_sec"]] - startTimeInSeconds
126.     action <- row[["action"]]
127.     cacheValue <- rowActionsCache[[action]]
128.     if (is.null(cacheValue)) {
129.       rowActionsCache[[action]] <- calculatedTime
130.     } else {
131.       previousTime <- cacheValue
132.       entry <- list()
133.       entry[["action"]] <- decorateAction(row[["action"]])
134.       entry[["start_time"]] <- previousTime
135.       entry[["end_time"]] <- calculatedTime
136.       entry[["duration"]] <- (calculatedTime - previousTime)
137.       result[[counter]] <- entry
138.       counter <- counter+1
139.       rowActionsCache[[action]] <- NULL
140.     }
141.   }
142.   return(result)
143. }
144.  
145. getActionPairsPerDuration <- function(pairs, start, end) {
146.   matchingPairs <- select(pairs, function(pair) {
147.     startedInPeriod <- pair[["start_time"]] > start & pair[["start_time"]] <= end
148.     endedInPeriod <- pair[["end_time"]] > start & pair[["end_time"]] <= end
149.     return(startedInPeriod | endedInPeriod)
150.   })
151.   withTimesAlignedToPeriod <- map(matchingPairs, function(pair) {
152.     entry <- pair
153.     if (entry[["start_time"]] < start) { entry["start_time"] <- start }
154.     if (entry[["end_time"]] > end) { entry["end_time"] <- end }
155.     entry[["duration"]] <- (entry[["end_time"]] - entry[["start_time"]])
156.     return(entry)
157.   })
158.   return(withTimesAlignedToPeriod)
159. }
160.  
161. scopeDownPairsToAction <- function(pairs, action) {
162.   return(select(pairs, function(pair) { pair[["action"]] == action }))
163. }
164.  
165. calculateAmountPerAction <- function(pairs, action) {
166.   return(length(scopeDownPairsToAction(pairs, action)))
167. }
168.  
169. calculateTotalDurationPerAction <- function(pairs, action) {
170.   return(sum(scopeDownPairsToAction(pairs, action), "duration"))
171. }
172.  
173. calculateAverageDurationPerAction <- function(pairs, action) {
174.   amountPerAction <- calculateAmountPerAction(pairs, action)
175.   totalDuration <- calculateTotalDurationPerAction(pairs, action)
176.   if (amountPerAction == 0) {
177.     return(0)
178.   } else {
179.     return(totalDuration / amountPerAction)
180.   }
181. }
182.  
183. filenames <- list.files("data/", "*.bvs")
184.  
185. # procedure
186.  
187. finalData <- list()
188. for (actionName in actionNames) {
189.   finalData[[actionName]] <- list()
190.   for (filename in filenames) {
191.     finalData[[actionName]][[filename]] <- list()
192.     fullPath = paste("data", filename, sep="/")
193.     pairsFromFile = getActionPairsFromFile(fullPath)
194.     for(period in periods) {
195.       periodIndex = paste(period[1], "-", period[2], sep = "")
196.       finalData[[actionName]][[filename]][[periodIndex]] <- list()
197.       pairsFromPeriod = getActionPairsPerDuration(pairsFromFile, period[1], period[2])
198.       finalData[[actionName]][[filename]][[periodIndex]][["n"]] = calculateAmountPerAction(pairsFromPeriod, actionName)
199.       finalData[[actionName]][[filename]][[periodIndex]][["total"]] = calculateTotalDurationPerAction(pairsFromPeriod, actionName)
200.       finalData[[actionName]][[filename]][[periodIndex]][["average"]] = calculateAverageDurationPerAction(pairsFromPeriod, actionName)
201.     }
202.   }
203. }
204.  
205. generateCsvDataForAction <- function(actionName, data) {
206.   props <- c("n", "total", "average")
207.   csvData <- list()
208.   csvData[["Filenames"]] <- generateVectorFromCollection(filenames)
209.   for(period in periods) {
210.     for(prop in props) {
211.       numbers <- generateVectorFromCollection(map(filenames, function(filename) {
212.         return(round(data[[actionName]][[filename]][[indexNameForPeriod(period)]][[prop]], 2))
213.       }))
214.       header <- paste(prop, decoratePeriod(period), sep=" ")
215.       csvData[[header]] <- numbers
216.     }
217.   }
218.   return(csvData)
219. }
220.  
221. outputFileName = "output.csv"
222. for(actionName in actionNames) {
223.   write(actionName, file=outputFileName, append=T)
224.   write("", file=outputFileName, append=T)
225.   data <- generateCsvDataForAction(actionName, finalData)
226.   write.table(data, file=outputFileName, append=T, row.names=F)
227.   write("", file=outputFileName, append=T)
228.   write("", file=outputFileName, append=T)
229. }
230.