Base64encoding.Rmd

---
title: "Base64Encoding"
author: "Anjani Bajaj"
date: "October 30, 2017"
output: html_document
---

```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```

## Encoding for large ECG dataset
This is the ecg data which is to be encoded in base64. The summary of the data looks like below:

```{r ecg}
ecg <- read.csv("ecg_sample.csv")
ecg$Time <- ecg$Time - min(ecg$Time)              
summary(ecg)
```

## Subtract the most negative value to make the dataset non-negative
These non-negative values can then be packed and encoded to transmit over the network
```{r}
c<-min(ecg$ec)
ecg$ec <- ecg$ec-c
summary(ecg)
head(ecg)

```

Let us take 1 sec of data, i=125
```{r}
i <- 124
newecg <- ecg[1:i,]
object.size(newecg$ec)
summary(newecg)
```

##A function to pack a vector of non-negative 12 bit integer values
```{r}
pack2values <- function(v1, v2){ # must be non-negative integers in 12-bit range
  mask8 <- 255
  bitvec <- bitwShiftL(v1, 12) + v2 # 24 bit: v1v2
  as.raw(c(bitwAnd(bitwShiftR(bitvec, 16), mask8), bitwAnd(bitwShiftR(bitvec, 8), mask8), bitwAnd(bitvec, mask8)))
}

newpack <- function(vec){
  count <- 1
  pack <- c()
  answer <- c()
  for (value in vec){
    pack<-append(pack,value)
    if(count%%2==0){
      res<-pack2values(pack[1],pack[2])
      answer <- append(answer,res)
      pack <- c()
    }
    count <- count +1
  }
  return(answer)
}
pack2values(newecg$ec[1], newecg$ec[2])
packedVector <- newpack(newecg$ec)
```
The packed vector looks like this
```{r}
packedVector
```

## Base64 encoding from the library caTools to encode the packed vector 
```{r}
library(caTools)
encodedVector <- base64encode(packedVector, size=NA, endian=.Platform$endian)
nchar(encodedVector)
encodedVector
```

## The way to decode the vector
The vector should be decoded after it is received at the destination after transmission
```{r}
decodedVector <- base64decode(encodedVector, size=NA, typeof(packedVector))
nchar(decodedVector)
decodedVector
```

Functions to unpack the decoded vector
```{r}
unpack2values <- function(pv){ # 3 8 bit values
  mask4 <- 15
  mask12 <- 2047 
  makeLast40s <- 4080
  pv1 <- as.integer(pv[1])
  pv2 <- as.integer(pv[2])
  pv3 <- as.integer(pv[3])
  res <- bitwAnd(bitwShiftL(bitwAnd(pv1, mask12), 4), makeLast40s) + bitwAnd(bitwShiftR(pv2,4), mask4) 
  res2 <- bitwShiftL(bitwAnd(pv2, mask4), 8) + pv3
  answer <- c(res, res2)
  return (answer)
}

newunpack <- function(vec){
  count <- 1
  unpack<- c()
  result <- c()
  for(value in vec){
    unpack <- append(unpack, value)
    if(count%%3 == 0){
      answer <- unpack2values(unpack)
      result <- append(result, answer)
      # print(result)
      unpack <-c()
    }
    count <- count + 1
  }
  return(result)
}
```

### Unpacking Vector
```{r}
retrievedVector <- newunpack(decodedVector)
retrievedVector
```

This is the original vector
```{r}
newecg$ec
```

#Final Test to check if these two vectors are same
```{r}
all.equal(packedVector, decodedVector)
all.equal(newecg$ec, retrievedVector)
```

##Plots to compare the difference
### Plot for the original data 
```{r, echo=FALSE}
plot_timespan <- function(t1, t2, ecg_data){
  with(ecg_data[ecg_data$Time >=t1 & ecg_data$Time < t2,],
       plot(ec ~ Time, type='l')
  )
}

plot_timespan(0, 977, ecg)
```


### Plot for the retrieved data
```{r, echo=FALSE}
plot(retrievedVector, type='l')