diveMove (version 1.1)

diveMove-internal: Internal diveMove Functions

Description

Functions used for very particular tasks within larger functions in diveMove

Usage

.depthFilter(depth, k, probs, depth.bounds, na.rm)
.diveIndices(diveID, diveNo)
.getInterval(time)
.speedStats(x, vdist)
.night(time, sunrise.time, sunset.time)
.rleActivity(time, act, interval)
.speedCol(x)
.zoc(time, depth, method, control)

Arguments

depth

Numeric vector with depth in m.

k

Vector of moving window width integers (coerced to integer by runquantile) to be applied sequentially.

probs

Vector of quantiles to extract at each step indicated by k (so it must be as long as k).

depth.bounds

Numeric vector of length two, with minimum and maximum depth to bound the search for the surface.

na.rm

Should NA values be removed prior to calculating running quantiles?

diveID

Numeric vector of all dive and non dive IDs.

diveNo

Numeric vector of unique dive indices to extract from diveID.

time

POSIXct object representing time.

x

For .speedStats, a matrix with a dive's section data. A single dive's data: 3-col matrix with time, depth, and speed. For .speedCol, a data frame where names are searched for strings matching .speedNames (see Details

vdist

Vertical distance travelled during this time. If vdist is missing, then it's all horizontal movements (no angles).

sunrise.time, sunset.time

Passed from plotTD.

act

A numeric vector indicating the activity for every element of time.

interval

Sampling interval in seconds.

method

Character string to indicate the method to use for zero offset correction. One of visual, offset, or filter (see Details).

control

Named list of control parameters to be used for ZOC method filter (k, probs, na.rm) and offset (offset).

Value

• .diveIndices returns a numeric vector with the indices of dives (and their beginning/end indices) in diveID.

  .getInterval returns a scalar, the mode of intervals between time readings.

  .speedStats returns a 3-column matrix with total distance, mean speed, and angle for a section of a dive.

  .night returns a list with sunrise and sunset times for dates in time.

  .speedCol returns column number where speed is located in x.

  .rleActivity returns a list with components:

  • time.br:
  {A factor dividing act into different periods of activity.}

• time.peract:
• {The duration of each period of activity.}
• beg.time, end.time:
• {POSIXct objects indicating the beginning and ending times of each period of activity.}

code

length(k) + 1

sQuote

method

Details

These functions are not meant to be called directly by the user, as he/she could not care less (right?). This may change in the future. Nonetheless, they can be called in the usual way for functions that are not exported: diveMove:::.functionName.

.depthFilter performs the zero-offset correction with method=filter. It takes a numeric vector and applies a running quantile to it, and the process is repeated zero or more times on the filtered/smooth vector from the previous process.

.diveIndices takes a numeric vector with sequences of dive numbers, and selects the indices of dive numbers listed uniquely in the vector given as its second argument.

.getInterval takes a POSIXct object and calculates the the most frequent interval between successive elements.

.speedStats takes matrix of time and speed, and an optional vector of vertical distance travelled between segments, and calculates the total vertical distance travelled, mean speed, and angle. Input and output correspond to a single section of a dive.

.night takes a POSIXct object, sunrise and sunset time strings to provide a list of sunrise and sunset times for each day in the POSIXct input.

.rleActivity takes a factor indicating different activity phases, their associated time, and the sampling interval to return a factor uniquely identifying each phase of activity, i.e. labelling them. In addition, it returns the duration of each phase, and their beginning and end times.

.speedNames is a character vector with possible names for a speed vector.

.speedCol takes a data.frame and checks whether there is a column with a name matching one of those in .speedNames.

.zoc is the main workhorse for the zero-offset correction ZOC procedure in calibrateDepth. It takes a POSIXct object, corresponding numeric depth vector, a string representing a method to use for the procedure, and a list of control parameters for the chosen method to perform ZOC.

Examples

data(divesTDR)

times <- getTime(divesTDR)
depths <- getDepth(divesTDR)

## This can take too long
## .depthFilter

d.filter <- diveMove:::.depthFilter(depth=depths, k=c(3, 5760),
                                    probs=c(0.5, 0.02), depth.bounds=c(0, 5),
                                    na.rm=TRUE)
## Set negative depths to zero
d.filter[d.filter[, 3] < 0, 3] <- 0

## Plotting

idx <- seq(95, 6000)		# try different slices
idx <- seq(nrow(d.filter))
## Look at the top 10 m only plus a few meters above
ylim <- c(-10, 5)

layout(seq(3))
plot(times[idx], -depths[idx], type="l", col="gray",
     ylab="Depth (m)", ylim=ylim)
abline(h=0, lty=2)
legend("topleft", legend="original", lty=1, col="gray")
plot(times[idx], -d.filter[idx, 1], type="l", col=2,
     ylab="Depth (m)", ylim=ylim)
abline(h=0, lty=2)
lines(times[idx], -d.filter[idx, 2])
legend("topleft", legend=colnames(d.filter)[-3],
       lty=1, col=c(2, 1))
plot(times[idx], -d.filter[idx, 3], type="l", ylim=ylim,
     ylab="Depth (m)"); abline(h=0, lty=2)
legend("topleft", legend=paste("Original -", colnames(d.filter)[2]),
       lty=1)