Package 'emuR'

Description

The emuR package provides the next iteration of the EMU Speech Database Management System with database management, data extraction, data preparation and data visualization facilities.

Details

This package is part of the next iteration of the EMU Speech Database Management System (EMU-SDMS) which aims to be as close to an all-in-one solution for generating, manipulating, querying, analyzing and managing speech databases as possible. For an overview of the system please visit this URL: http://ips-lmu.github.io/EMU.html.

It can be viewed as the main component of the EMU-SDMS as it acts as the central instance that is able to interact with every component of the system. It takes care of database managing duties by being able to interact with a speech database that is stored in the emuDB format. Further, it has easy to understand and learn yet expressive and powerful querying mechanics, that allow the user to easily query the annotation structures of the database. Lastly it provides easy data extraction capabilities that extract data (e.g. formant values) which corresponds to the result of a query.

For an introduction to the emuR package please see the emuR_intro vignette by calling: vignette('emuR_intro')

For information about the emuDB database format please see the emuDB vignette by calling: vignette('emuDB')

For information about the query language used by the EMU-SDMS please see the EQL vignette by calling: vignette('EQL')

Typical work-flow in emuR (emuDB required):

1. Load database into current R session - load_emuDB

2. Database annotation / visual inspection - serve and connect the EMU-webApp to the local server

3. Query database - query (sometimes followed by requery_hier or requery_seq)

4. Get trackdata (e.g. formant values) for the result of a query - get_trackdata

5. Data preparation

6. Visual data inspection

7. Further analysis and statistical processing

TIP: for a browsable overview of all the functions provided by emuR simply run the command help.start() -> click on packages -> click on emuR

Author(s)

Maintainer: Markus Jochim [email protected] (ORCID)

Authors:

• Raphael Winkelmann [email protected]

• Klaus Jaensch [email protected] [contributor]

• Steve Cassidy [email protected] [contributor]

• Jonathan Harrington [email protected] [contributor]

References

Harrington, J. (2010). The Phonetic Analysis of Speech Corpora. Blackwell.

See Also

Useful links:

• https://github.com/IPS-LMU/emuR

• https://ips-lmu.github.io/The-EMU-SDMS-Manual/

• Report bugs at https://github.com/IPS-LMU/emuR/issues

Examples

## Not run: 
# create demo data including an emuDB called "ae" 
create_emuRdemoData(dir = tempdir())

# construct path to demo emuDB
path2ae = file.path(tempdir(), "emuR_demoData", "ae")

# load emuDB into current R session
ae = load_emuDB(path2ae)

# query loaded emuDB
lvowels = query(ae, "Phonetic = i: | u: | o:")

# extract labels from query result 
lvowels.labs = label(lvowels)

# list all ssffTrackDefinitions of emuDB
list_ssffTrackDefinitions(ae)

# get formant trackdata defined in ssffTrackDefinitions "fm" for query result
lvowels.fm = get_trackdata(ae, lvowels, "fm")

# extract track values at temporal midpoint of segments
lvowels.fmCut = dcut(lvowels.fm, .5, prop = TRUE)

# Plot the data as time signal and formant card
dplot(lvowels.fm[,1:2], lvowels.labs, normalise=TRUE, main = "Formants over vowel duration")
eplot(lvowels.fmCut[,1:2], lvowels.labs, dopoints=TRUE, 
      doellipse=FALSE, main = "F1/F2 of vowel midpoint", form=TRUE, 
      xlab = "F2 in Hz", ylab = "F1 in Hz")
      
      
# Plot of spectral data from 50% of aspiration duration
hs = query(ae,"Phonetic = H")
hs.labs = label(hs)
hs.dft = get_trackdata(ae, hs, "dft")
hs.dftCut = dcut(hs.dft, .5, prop=TRUE)
plot(hs.dftCut, hs.labs, main = "Spectral data of aspiration")


## End(Not run)

Description

Add files to existing bundles of specified session of emuDB. Do not use this function to import new recordings (media files) and create bundles; see ?import_mediaFiles to import new recordings. The files that are found in dir that have the extension fileExtension will be copied into the according bundle folder that have the same basename as the file. Note that the same bundle name may appear in different sessions, therefore you must specify the session in targetSessionName. For more information on the structural elements of an emuDB see vignette{emuDB}. Note that adding files does not mean the emuDB is automatically using these, unless you have defined the usage of these files (e.g. by ssffTrackDefinitions).

Usage

add_files(emuDBhandle, dir, fileExtension, targetSessionName = "0000")

Arguments

Examples

## Not run: 

##################################
# prerequisite: loaded ae emuDB 
# (see ?load_emuDB for more information)

# specify path to folder containing the following
# files we wish to add to: 
# msajc003.zcr, msajc010.zcr, msajc012.zcr, msajc015.zcr, 
# msajc022.zcr, msajc023.zcr and msajc057.zcr 
path2dir = "/path/to/dir/"

# add the files to session "0000" of the "ae" emuDB
add_files(emuDBhandle = ae,
          dir = path2dir,
          fileExtension = "zcr",
          targetSessionName = "0000")


## End(Not run)

Description

Add / List / Remove label group to / of / from a specific attribute definition. This label group can be used as a short hand to reference groups of labels specific to an attribute definition (compared to global label groups that are added by add_labelGroup) in a query. A common example would be to add a label group for something like the phonetic category of nasals to be able reference them as "nasals" in a query. For more information on the structural elements of an emuDB see vignette(emuDB).

Usage

add_attrDefLabelGroup(
  emuDBhandle,
  levelName,
  attributeDefinitionName,
  labelGroupName,
  labelGroupValues
)

list_attrDefLabelGroups(emuDBhandle, levelName, attributeDefinitionName)

remove_attrDefLabelGroup(
  emuDBhandle,
  levelName,
  attributeDefinitionName,
  labelGroupName
)

Arguments

See Also

add_labelGroup

Examples

## Not run: 

##################################
# prerequisite: loaded ae emuDB 
# (see ?load_emuDB for more information)

sampaNasals = c("m", "F", "n", "J", "N")

# add these values to the default Phonetic attribute
# definition of the Phonetic level of the ae emuDB
add_attrDefLabelGroup(emuDBhandle = ae,
                      levelName = "Phonetic",
                      attributeDefinitionName = "Phonetic",
                      labelGroupName = "sampaNasals",
                      labelGroupValues = sampaNasals)

# query the labelGroup
query(ae, "Phonetic=sampaNasals")


# list attribute definition label groups
# of attributeDefinition "Phonetic" of the level "Phonetic"
# of the ae emuDB
list_attrDefLabelGroups(emuDBhandle = ae, 
                        levelName = "Phonetic" , 
                        attributeDefinitionName = "Phonetic")

# remove the newly added attrDefLabelGroup
remove_attrDefLabelGroup(emuDBhandle = ae,
                         levelName = "Phonetic",
                         attributeDefinitionName = "Phonetic",
                         labelGroupName = "sampaNasals")


## End(Not run)

Description

Add / List / Remove label group that can be used as a short hand to reference groups of labels that are globally defined for the entire database (compared to attribute definition specific label groups that are added by add_attrDefLabelGroup) in a query. A common example would be to add a label group for something like the phonetic category of nasals to be able to reference them as "nasals" in a query. In theory you could use a labelGroupName as a label instance within the level, but since this could lead to serious confusion, it is better avoided. For users transitioning from the legacy EMU system: Do not confuse a labelGroup with legal labels: a labelGroup had the unfortunate name 'legal labels' in the legacy EMU system. For more information on the structural elements of an emuDB see vignette{emuDB}.

Usage

add_labelGroup(emuDBhandle, name, values)

list_labelGroups(emuDBhandle)

remove_labelGroup(emuDBhandle, name)

Arguments

See Also

add_attrDefLabelGroup

Examples

## Not run: 

##################################
# prerequisite: loaded ae emuDB 
# (see ?load_emuDB for more information)

sampaNasals = c("m", "F", "n", "J", "N")

# add these values to the ae emuDB
# as a globally available labelGroup
add_labelGroup(emuDBhandle = ae,
               name = "sampaNasals",
               values = sampaNasals)

# query the labelGroup in the "Phonetic" level
query(emuDBhandle = ae, 
      query = "Phonetic == sampaNasals")

# query the labelGroup in the "Phoneme" level
query(emuDBhandle = ae, 
      query = "Phoneme == sampaNasals")

# list global label groups of ae emuDB
list_labelGroups(emuDBhandle = ae)

# remove the newly added labelGroup
remove_labelGroup(emuDBhandle = ae,
                  name = "sampaNasals")

## End(Not run)

Description

Add / List / Remove database operation functions for level definitions. A level is a more general term for what is often referred to as a "tier". It is more general in the sense that people usually expect tiers to contain time information. Levels can either contain time information if they are of the type "EVENT" or of the type "SEGMENT" but are timeless if they are of the type "ITEM". For more information on the structural elements of an emuDB see vignette(emuDB). Note that a level cannot be removed, if it contains instances of annotation items or if it is linked to another level. Further note, renaming a level definition can be done using rename_attributeDefinition.

Usage

add_levelDefinition(
  emuDBhandle,
  name,
  type,
  rewriteAllAnnots = TRUE,
  verbose = TRUE
)

list_levelDefinitions(emuDBhandle)

remove_levelDefinition(
  emuDBhandle,
  name,
  rewriteAllAnnots = TRUE,
  force = FALSE,
  verbose = TRUE
)

Arguments

Examples

## Not run: 

##################################
# prerequisite: loaded ae emuDB 
# (see ?load_emuDB for more information)

# add level called "Phonetic2" to the ae emuDB
# that could for example contain the transcriptions of a second annotator
add_levelDefinition(emuDBhandle = ae,
                    name = "Phonetic2",
                    type = "SEGMENT")
                    
# list level definition of ae emuDB
list_levelDefinitions(emuDBhandle = ae)

# remove newly added level definition
remove_levelDefinitions(emuDBhandle = ae,
                        name = "Phonetic2")

## End(Not run)

Description

Add / List / Remove new link definition to / of / from emuDB. A link definition specifies the relationship between two levels, the super-level and the sub-level. The entirety of all link definitions of a emuDB specifies the hierarchical structure of the database. For more information on the structural elements of an emuDB see vignette(emuDB).

Usage

add_linkDefinition(emuDBhandle, type, superlevelName, sublevelName)

list_linkDefinitions(emuDBhandle)

remove_linkDefinition(
  emuDBhandle,
  superlevelName,
  sublevelName,
  force = FALSE,
  verbose = TRUE
)

Arguments

Details

Link type descriptions:

• "ONE_TO_MANY": A single ITEM of the super-level can be linked to multiple ITEMs of the sub-level

• "MANY_TO_MANY": Multiple ITEMs of the super-level can be linked to multiple ITEMs of the sub-level

• "ONE_TO_ONE": A single ITEM of the super-level can be linked to a single ITEM of the sub-level

For all link types the rule applies that no links are allowed to cross any other links. Further, a linkDefinition can not be removed, if there are links present in the emuDB.

Examples

## Not run: 

##################################
# prerequisite: loaded emuDB that was converted
# using the convert_TextGridCollection function called myTGcolDB
# (see ?load_emuDB and ?convert_TextGridCollection for more information)

# add link definition from super-level "Phoneme"
# to sub-level "Phonetic" of type "ONE_TO_MANY"
# for myTGcolDB emuDB
add_linkDefinition(emuDBhandle = myTGcolDB,
                   type = "ONE_TO_MANY",
                   superlevelName = "Phoneme",
                   sublevelName = "Phonetic")

# list link definitions for myTGcolDB emuDB
list_linkDefinitions(emuDBhandle = myTGcolDB)

# remove newly added link definition
remove_linkDefinition(emuDBhandle = myTGcolDB,
                      superlevelName = "Phoneme",
                      sublevelName = "Phonetic")



## End(Not run)

Description

Add / List / Remove perspective to / of / from emuDB. The EMU-webApp subdivides different ways to look at an emuDB into so called perspectives. These perspectives, between which you can switch in the web application, contain information on what levels are displayed, which ssffTracks are drawn, and so on. For more information on the structural elements of an emuDB see vignette{emuDB}.

Usage

add_perspective(emuDBhandle, name)

list_perspectives(emuDBhandle)

remove_perspective(emuDBhandle, name)

Arguments

Examples

## Not run: 

##################################
# prerequisite: loaded ae emuDB 
# (see ?load_emuDB for more information)

# add perspective called "justTones" to the ae emuDB
add_perspective(emuDBhandle = ae,
                name = "justTones") 
                
# add levelCanvasOrder so only the "Tone" level is displayed
set_levelCanvasesOrder(emuDBhandle = ae, 
                       perspectiveName = "justTones", 
                       order = c("Tone"))

# list perspectives of ae emuDB
list_perspectives(emuDBhandle = ae)

# remove newly added perspective
remove_perspective(emuDBhandle = ae,
                   name = "justTones")
                   

## End(Not run)

Description

Add / List / Remove ssffTrackDefinition to / from / of emuDB. An ssffTrack (often simply referred to as a track) references data that is stored in the Simple Signal File Format (SSFF) in the according bundle folders. The two most common types of data are:

• complementary data that was acquired during the recording such as data acquired during electromagnetic articulographic (EMA) or electropalatography (EPG) recordings;

• derived data, i.e. data that was calculated from the original audio signal such as formant values and their bandwidths or the short-term Root Mean Square amplitude of the signal.

For more information on the structural elements of an emuDB see vignette(emuDB).

Usage

add_ssffTrackDefinition(
  emuDBhandle,
  name,
  columnName = NULL,
  fileExtension = NULL,
  fileFormat = NULL,
  onTheFlyFunctionName = NULL,
  onTheFlyParams = NULL,
  onTheFlyOptLogFilePath = NULL,
  verbose = TRUE,
  interactive = TRUE
)

list_ssffTrackDefinitions(emuDBhandle)

remove_ssffTrackDefinition(emuDBhandle, name, deleteFiles = FALSE)

Arguments

Examples

## Not run: 

##################################
# prerequisite: loaded ae emuDB 
# (see ?load_emuDB for more information)

# add ssff track definition to ae emuDB
# calculating the according SSFF files (.zcr) on-the-fly
# using the wrassp function "zcrana" (zero-crossing-rate analysis)
add_ssffTrackDefinition(emuDBhandle = ae,
                        name = "ZCRtrack",
                        onTheFlyFunctionName = "zcrana")
                        
# add ssff track definition to ae emuDB
# for SSFF files that will be added later (either
# by adding files to the emuDB using 
# the add_files() function or by calculating
# them using the according function provided 
# by the wrassp package)
add_ssffTrackDefinition(emuDBhandle = ae,
                        name = "formants",
                        columnName = "fm",
                        fileExtension = "fms")

# list ssff track definitions for ae emuDB
list_ssffTrackDefinitions(emuDBhandle = ae)

# remove newly added ssff track definition (does not delete 
# the actual .zcr files)
remove_ssffTrackDefinition(emuDBhandle = ae,
                           name = "ZCRtrack")


## End(Not run)

Description

Add / List / Rename / Remove database operation functions for attribute definition to / of / from an existing level definition of an emuDB. Attribute definitions can be viewed as definitions of parallel labels for the annotational units (ITEMs) of the emuDB. Each level definition is required to have at least one default attribute definition that has the same name as the level definition (automatically created by add_levelDefinition). For more information on the structural elements of an emuDB see vignette(emuDB). Note that as with level definitions, an attribute definition to a level cannot be removed, if it contains labels in the emuDB.

As the only one of these operations, rename_attributeDefinition can also be used to manipulate (i.e. rename) a level definition. It is therefore not necessary to specify the name of the level that the attribute definition belongs to. While renaming a level or attribute definition, emuR will (1) rewrite the levelDefinitions in DBconfig, (2) rewrite the linkDefinitions in DBconfig, (3) rewrite the perspectives in DBconfig, (4) rewrite the anagestConfig in DBconfig, and (5) rewrite all _annot.json files. (5) May take quite a while, depending on the number of bundles in the database.

Usage

add_attributeDefinition(
  emuDBhandle,
  levelName,
  name,
  type = "STRING",
  rewriteAllAnnots = TRUE,
  verbose = TRUE
)

list_attributeDefinitions(emuDBhandle, levelName)

rename_attributeDefinition(
  emuDBhandle,
  origAttrDef,
  newAttrDef,
  verbose = TRUE
)

remove_attributeDefinition(
  emuDBhandle,
  levelName,
  name,
  force = FALSE,
  rewriteAllAnnots = TRUE,
  verbose = TRUE
)

Arguments

Examples

## Not run: 

##################################
# prerequisite: loaded ae emuDB 
# (see ?load_emuDB for more information)

# add additional attribute definition to the "Phonetic" level
# of the ae emuDB that will contain the UTF8 IPA
# symbols of the phonetic transcriptions
add_attributeDefinition(emuDBhandle = ae,
                        levelName = "Phonetic",
                        name = "IPA-UTF8")
                        
# list attribute definitions for level "Word"
# of the ae emuDB
list_attributeDefinitions(emuDBhandle = ae, 
                          levelName = "Word")

# remove newly added attributeDefinition
remove_attributeDefinition(emuDBhandle = ae,
                           levelName = "Phonetic",
                           name = "IPA-UTF8")

## End(Not run)

Description

The function converts a vector, matrix, or EMU-trackdata object into an object of the same class and of class 'spectral'

Usage

as.spectral(trackdata, fs)

Arguments

Details

If fs is a single element numeric vector, then the frequencies of trackdata are defined to extend to fs/2. If fs is missing, then the frequencies are 0:(N-1) where N is the length of trackdata.

Value

The same object but of class 'spectral'.

Author(s)

Jonathan Harrington

See Also

is.spectral plot.spectral

Examples

vec = 1:10
as.spectral(vec, 2000)
mat = rbind(1:10, 1:10)
as.spectral(mat)
# turn a spectral trackdata object into a trackdata object
tr = as.trackdata(rbind(fric.dft$data), fric.dft$index, fric.dft$ftime)
# turn it into a spectral trackdata object with sampling freq 16 kHz
tr = as.spectral(tr, 16000)
# list the frequencies
trackfreq(tr)
# Notice that only the $data is made into a spectral matrix,
# not the entire trackdata object
# so this is trackdata
class(tr)
# this is a spectral matrix
class(tr$data)

Description

Create an Emu trackdata object from a raw data matrix.

Usage

as.trackdata(data, index, ftime, trackname = "")

Arguments

Details

Emu trackdata objects contain possibly multi-column numerical data corresponding to a set of segments from a database. Data for each segment takes up a number of rows in the main data matrix, the start and end rows are stored in the index component. The ftime component contains the start and end times of the segment data.

Trackdata objects are returned by the get_trackdata function.

Value

The components are bound into a trackdata object.

See Also

get_trackdata dplot

Examples

# make a trackdata object of two data segments
data1 <- matrix( 1:10, ncol=2 )
data2 <- matrix( 11:20, ncol=2 )

nd1 <- nrow(data1)
nd2 <- nrow(data2)
index <- rbind( c( 1, nd1 ), c(nd1+1,nd1+nd2) )

times <- rbind( c( 100.0, 110.0 ), c( 200.0, 210.0 ) )

tdata <- as.trackdata( rbind( data1, data2 ), index, times, trackname="fake")

# describe the data
summary(tdata)
# get the data for the first segment
tdata[1]
# and the second
tdata[2]

Description

Autobuild links between two time levels. This is typically done when converting from a database / annotation format that allows parallel time tiers / levels but does not permit annotational units to be linked to each other, except by matching time information (such as Praat's TextGrid format). The super-level has to be of the type SEGMENT and the sub-level either of type EVENT or of type SEGMENT. If this is the case and a according link definition is defined for the emuDB, this function automatically links the events or segments of the sub-level which occur within (startSample to (startSample + sampleDur)) the segments of the super-level to those segments.

Usage

autobuild_linkFromTimes(
  emuDBhandle,
  superlevelName,
  sublevelName,
  rewriteAllAnnots = TRUE,
  convertSuperlevel = FALSE,
  backupLevelAppendStr = "-autobuildBackup",
  newLinkDefType = NULL,
  verbose = TRUE
)

Arguments

Details

The type of link definition (ONE_TO_MANY, MANY_TO_MANY, ONE_TO_ONE) is relevant whether a link is generated or not (e.g. overlapping segments are linked in a MANY_TO_MANY relationship but not in a ONE_TO_MANY relationship). For more information on the structural elements of an emuDB see vignette(emuDB).

See Also

add_linkDefinition

Examples

## Not run: 

##################################
# prerequisite: loaded myTGcolDB emuDB 
# (see ?create_emuRdemoData, ?convert_TextGridCollection, 
#  and vignette(emuR_intro) for more information)

# add linkDefinition as one has to be present for
# the autobuild function to work
add_linkDefinition(emuDBhandle = myTGcolDB, 
                   type = "ONE_TO_MANY",
                   superlevelName = "Syllable",
                   sublevelName = "Phoneme")
  
# envoke autobuild function to build hierarchy for converted TextGridCollection
autobuild_linkFromTimes(emuDBhandle = myTGcolDB, 
                        superlevelName = "Syllable",
                        sublevelName = "Phoneme",
                        convertSuperlevel = TRUE)


## End(Not run)

Description

The calculation is done using the formulae Traunmueller (1990)

Usage

bark(f, inv = FALSE, ...)

Arguments

Details

If 'data' is a spectral object, then

the frequencies are changed so that they are proportional

to the Bark scale and such that the Bark intervals

between frequencies are con stant between the lowest

and highest frequencies. More specifically,

suppose that a spectral object has frequencies

at 0, 1000, 2000, 3000, 4000 Hz. Then the corresponding

frequencies extend in Bark between 0 and 17.46329 Bark

in four equal intervals, and linear interpolation

is used with the 'approx' function to obtain

the dB values at those frequencies. Negative frequencies

which are obtained for values of about less than 40 Hz

are removed in the case of spectral objects.

Value

A vector or matrix or spectral object of the same length and dimensions as data.

Author(s)

Jonathan Harrington

References

Traunmueller, H. (1990) "Analytical expressions for the tonotopic sensory scale" J. Acoust. Soc. Am. 88: 97-100.

See Also

mel,

plot.spectral

Examples

# convert Hertz values to Bark

        vec <- c(500, 1500, 2500)

        vec

        bark(vec)



        

        # convert Hertz values to Bark and back to Hertz

        bark(bark(vec, inv=TRUE))

        



        # convert the $data values in a trackdata object to Bark

        # create a new track data object

        t1 <- dip.fdat

        t1[1]

        



        # convert Hertz to Bark

        t1$data <- bark(t1$data)

        t1[1]



# warp the frequency axis of a spectral object such

# that it is proportional to the Bark scale.

w = bark(e.dft)

oldpar = par(mfrow=c(1,2))

plot(w, type="l")



# The values of w are at equal Bark intervals. Compare

# with

plot(e.dft, freq=bark(trackfreq(e.dft)))

# the latter has a greater concentration of values

# in a higher frequency range.

par(oldpar)

Description

binds different trackdata objects together

Usage

## S3 method for class 'trackdata'
bind(...)

Arguments

Description

An EMU dataset

Format

Three-columned matrix

Description

buildtrack() converts a list that is the output of by.trackdata() into a trackdata object if the list components are matrices whose rows are successive values in time.

Usage

buildtrack(mylist, ftime = NULL, trackname = "")

Arguments

Details

The default of by.trackdata() is to return a list. If each element of the list consists of a matrix whose rows are values occurring at the times given by the row dimension names of the matrix, then buildtrack() can be used to convert the list into a trackdata object. If the times are not given in the row dimension names, then these can be supplied as an additional argument to buildtrack()

Author(s)

Jonathan Harrington

See Also

by

Examples

#vowlax.fdat is a track data objects of formant of the vowlax segment list
   #calculate the difference between adjacent formant values
   p = by(vowlax.fdat[1,2],INDICES=NULL, diff)
   
   p
   
   
   #now build a track data object out of these values
   m = buildtrack(p)
   
   m

Description

A given function 'FUN' is applied to the data corresponding to each segment of data.

Usage

## S3 method for class 'trackdata'
by(data, INDICES = NULL, FUN, ..., simplify = FALSE)

Arguments

Details

It is the same as trapply but with the extension to subsume calculation to groups of segments. Note, if you do not want to apply the function fun to a special group of segments, use trapply instead.

Value

list or vector

Author(s)

Jonathan Harrington

See Also

trapply, by, trackdata dapply smooth apply

Examples

data(demo.vowels)
  data(demo.vowels.fm)


   #mean F1 subsumed for each vowel
   ################################
   lab = label(demo.vowels)
   by(demo.vowels.fm[,1], lab ,sapply,mean,simplify=FALSE)


   #mean F1 subsumed for segment onsets mids and offsets
   ##############################################
   data = demo.vowels.fm
   llabs = NULL
   for (ind in 1:dim(data$ftime)[1]) {
     seglabs = rep("mid",data$index[ind,2]-data$index[ind,1]+1)
     seglabs[1] = "on"
     seglabs[length(seglabs)] = "off"
     llabs = as.vector(c(llabs , seglabs))
   }

   by(demo.vowels.fm[,1], llabs , sapply, mean , simplify=FALSE)

   #mean F1 subsumed for segment onsets mids and offsets subsumed for each vowel
   #####################################################################
   by(demo.vowels.fm[,1], list(lab = lab, llabs = llabs) , sapply, mean , simplify=FALSE)

Description

Different track data objects from one segment list are bound by combining the $data columns of the track data object by columns.

Usage

## S3 method for class 'trackdata'
cbind(...)

Arguments

Details

All track data objects have to be track data of the same segment list. Thus $index and $ftime values have to be identically for all track data objects. Track data objects are created by get_trackdata(). The number of rows of the track data objects must match.

Value

A track data object with the same $index and ftime values of the source track data objects and with $data that includes all columns of $data of the source track data objects.

Author(s)

Jonathan Harrington

See Also

cbind, rbind.trackdata trackdata get_trackdata

Examples

data(vowlax)
   
   #segment list vowlax - first segment only 
   vowlax[1,]
   
   #F0 track data object for vowlax - first segment only 
   vowlax.fund[1,]
   
   #rms track data object for vowlax - first segment only 
   vowlax.rms[1,]
      
   
   #now combine both track data objects
   fund.rms.lax = cbind(vowlax.fund, vowlax.rms)
   
   #the combined track data object - first segment only
   #The first column keeps vowlax.fund data, the second keeps vowlax.rms data 
   fund.rms.lax[1,]

Description

classifies data

Usage

classify(data, train, metric = "bayes")

Arguments

Value

The classification matrix.

Author(s)

Jonathan Harrington

Examples

## The function is currently defined as
function (data, train, metric = "bayes") 
{
    probs <- distance(data, train, metric = metric)
    if (metric == "bayes") {
        best <- apply(probs, 1, max)
    }
    else if (metric == "mahal") {
        best <- apply(probs, 1, min)
    }
    result <- rep("", length(best))
    for (lab in 1:length(train$label)) {
        tmp <- probs[, lab] == best
        result[tmp] <- train$label[lab]
    }
    result
  }

Description

The function classifies all point specified within the ranges of xlim and ylim based on the training model specified in model. It then produces a two-dimensional plot colour-coded for classifications.

Usage

classplot(
  model,
  xlim,
  ylim,
  N = 100,
  pch = 15,
  col = NULL,
  legend = TRUE,
  position = "topright",
  bg = "gray90",
  ...
)

Arguments

Author(s)

Jonathan Harrington

See Also

qda, lda, svm of e1071 package. There is a function plot.svm which produces a prettier plot for SVMs.

Examples

library(MASS)
# Data from female speaker 68
temp = vowlax.spkr=="68"
# Quadratic discriminant analysis
fm.qda = qda(vowlax.fdat.5[temp,1:2], vowlax.l[temp])
# Linear discriminant analysis
fm.lda = lda(vowlax.fdat.5[temp,1:2], vowlax.l[temp])

xlim=c(0,1000)
ylim=c(0,3000)

oldpar = par(mfrow=c(1,2))
classplot(fm.qda, xlim=xlim, ylim=ylim, main="QDA")
classplot(fm.lda, xlim=xlim, ylim=ylim, main="LDA")

par(oldpar)


# install.packages("e1071")
# library(e1071)
# Support vector machine
## Not run: fm.svm = svm(vowlax.fdat.5[temp,1:2], factor(vowlax.l[temp]))
## Not run: xlim = range(vowlax.fdat.5[temp,1])
## Not run: ylim = range(vowlax.fdat.5[temp,2])
## Not run: classplot(fm.svm, xlim=xlim, ylim=ylim, xlab="F1", ylab="F2", main="SVM")

Description

Converts a Bas Partitur File Collection to an emuDB. Expects a collection of the following form: One master directory <sourceDir> containing any number of file pairs (= bundles). A file pair consists of an audio file with the extension <audioExt> and a BPF file with the extension <bpfExt>. Apart from extensions, the names of corresponding audio and BPF files must be identical. Each BPF file is converted into an emuDB annot file. An emuDB config file matching the data base is created after parsing.

Usage

convert_BPFCollection(
  sourceDir,
  targetDir,
  dbName,
  bpfExt = "par",
  audioExt = "wav",
  extractLevels = NULL,
  refLevel = NULL,
  newLevels = NULL,
  newLevelClasses = NULL,
  segmentToEventLevels = NULL,
  unifyLevels = NULL,
  verbose = TRUE
)

Arguments

See Also

convert_TextGridCollection, convert_legacyEmuDB

Examples

## Not run: 

##################################
# prerequisite: a dir with equally named file pairs *.wav and *.par
# (see ?create_emuRdemoData on how to create a demo)

# convert file pairs *.wav and *.par in /tmp/BPF_collection into emuRDB 'NewEmuR' in 
# dir /tmp/DirNewEmuR; the tier 'ORT' acts as the (word) reference tier; the 
# tier 'KAN' is one-to-one bound to 'ORT' as a label
convert_BPFCollection("/tmp/BPF_collection","/tmp/DirNewEmuR",'NewEmuR',
        bpfExt='par',audioExt='wav',refLevel='ORT',unifyLevels=c('KAN'))


## End(Not run)

Description

Converts an existing legacy EMU database to emuDB database structure. Copies or rewrites signal files and converts the database configuration and annotation data. The legacy database must be addressed by its template file.

Usage

convert_legacyEmuDB(
  emuTplPath,
  targetDir,
  dbUUID = uuid::UUIDgenerate(),
  verbose = TRUE,
  ...
)

Arguments

Details

The database will be converted if the legacy database template file emuTplPath could be found and successfully loaded and parsed. The legacy template file usually has the extension '.tpl'. The UUID of the new emuDB will be randomly generated by default. If targetDir does not exist, the directory and its parents will be created. A new directory with the name of the database and the suffix '_emuDB' will be created in the targetDir. If the new database directory exists already, the function stops with an error. The template file is converted to a JSON file.

Some of the flags of the legacy EMU template files are ignored (lines with this syntax: "set [flagName] [flagValue]", known ignored flag names are: 'LabelTracks', 'SpectrogramWhiteLevel', 'HierarchyViewLevels', 'SignalViewLevels'). Legacy EMU utterances are reorganized to sessions and bundles. The naming of the sessions depends on the wildcard path pattern of the primary track: If the path contains no wildcard, only one session with the name '0000' will be created. If the path contains one wildcard path element, the names of the directories matching the pattern will be used as session names. If the path contains more than one wildcard path element, the session name is the concatenation of directory names separated by an underscore character.

Media files (usually WAV files) are copied, SSFF track files are rewritten using the ASSP library of package wrassp by default (see option rewriteSSFFTracks below, see also read.AsspDataObj write.AsspDataObj). Annotations in EMU hierarchy (.hlb) files and ESPS label files are converted to one JSON file per bundle (utterance). Only those files get copied, which match the scheme of the template file. Additional files in the legacy database directories are ignored. The legacy EMU database will not be modified. For more information on the structural elements of an emuDB see vignette{emuDB}.

options is a list of key value pairs:

See Also

load_emuDB

Examples

## Not run: 
## Convert legacy EMU database specified by EMU 
## template file /mydata/EMU_legacy/ae/ae.tpl to directory /mydata/EMU/
## and load it afterwards

convert_legacyEmuDB("/mydata/EMU_legacy/ae/ae.tpl","/mydata/EMU/")
ae=load_emuDB("/mydata/EMU/ae_emuDB")

## Convert database "ae" and do not rewrite SSFF tracks 

convert_legacyEmuDB("/mydata/EMU_legacy/ae/ae.tpl",
"/mydata/EMU/",
options=list(rewriteSSFFTracks=FALSE))

## Convert legacy database "ae" from emuR demo data and load converted emuDB

create_emuRdemoData()
demoTplPath=file.path(tempdir(),"emuR_demoData/legacy_ae/ae.tpl")
targetDir=file.path(tempdir(),"converted_to_emuR")
convert_legacyEmuDB(demoTplPath,targetDir)
dbHandle=load_emuDB(file.path(targetDir,"ae_emuDB"))


## End(Not run)

Description

Converts a TextGridCollection to an emuDB by searching a given directory for .wav & .TextGrid files (default extensions) with the same base name. First, the function generates a file pair list containing paths to files with the same base name. It then generates an emuDB DBconfig based on the first TextGrid in this list which specifies the allowed level names and types in the new emuDB. After this it converts all file pairs to the new format, checking whether they comply to the newly generated database configuration. For more information on the emuDB format see vignette{emuDB}. Note that since Praat TextGrids do not permit explicit hierarchical structures, the created emuDB does not contain any links or link definitions. You can however use the autobuild_linkFromTimes function after the conversion process to automatically build a hierarchal structure.

Usage

convert_TextGridCollection(
  dir,
  dbName,
  targetDir,
  tgExt = "TextGrid",
  audioExt = "wav",
  tierNames = NULL,
  verbose = TRUE
)

Arguments

Examples

## Not run: 

##########################################################
# prerequisite: directory containing .wav & .TextGrid files
# (see \code{?create_emuRdemoData} how to create demo data)

# convert TextGridCollection and store 
# new emuDB in folder provided by tempdir()
convert_TextGridCollection(dir = "/path/to/directory/",
                           dbName = "myTGcolDB",
                           targetDir = tempdir())


# same as above but this time only convert 
# the information stored in the "Syllable" and "Phonetic" tiers
convert_TextGridCollection(dir = "/path/to/directory/", 
                           dbName = "myTGcolDB", 
                           targetDir = tempdir(),
                           tierNames = c("Syllable", "Phonetic"))


## End(Not run)

Description

This function takes as input pairs of media files (i.e. wav files) and plain text transcriptions files. It creates a new emuDB with one bundle per media file, and turns the associated transcription into an item in that bundle. For this purpose, media files and text files belonging to the same bundle must be named identically (with the exception of their respective file extensions). The newly created emuDB is stored in the target directory, and its handle is returned.

Usage

convert_txtCollection(
  dbName,
  sourceDir,
  targetDir,
  txtExtension = "txt",
  mediaFileExtension = "wav",
  attributeDefinitionName = "transcription",
  cleanWhitespaces = TRUE,
  verbose = TRUE
)

Arguments

See Also

convert_BPFCollection, convert_TextGridCollection

Description

Converts a trackdata tibble object of the form (==wide):

to its long form equivalent:

Usage

convert_wideToLong(td, calcFreqs = FALSE)

Arguments

Value

long form trackdata tibble object

Description

An EMU dataset

Format

segmentlist

Description

An EMU dataset

Format

segmentlist

Description

An EMU dataset

Format

segmentlist

Description

An EMU dataset

Format

segmentlist

Examples

data(coutts.rms)

Description

An EMU dataset

Format

trackdata object

Description

An EMU dataset

Format

segmentlist

Description

An EMU dataset

Format

trackdata object

Description

An EMU dataset

Format

vector of word label

Description

An EMU dataset

Format

trackdata object

Description

The function plots and/or sums digital sinusoids for different parameter settings.

Usage

cr(
  A = 1,
  k = 1,
  p = 0,
  N = 16,
  samfreq = NULL,
  duration = NULL,
  const = NULL,
  expon = NULL,
  plotf = TRUE,
  ylim = NULL,
  xlim = NULL,
  values = FALSE,
  xlab = "Time (number of points)",
  ylab = "Amplitude",
  type = "b",
  bw = NULL,
  dopoints = FALSE,
  ...
)

Arguments

Author(s)

Jonathan Harrington

See Also

crplot

Examples

# cosine wave
cr()

# doubling the frequency, 1/3 amplitude, phase = pi/4, 50 points
cr(A=1/3, k=2, p=pi/4, N=50)

# sum 3 sinusoids of different frequencies)
cr(k=c(1, 3, 4))

# sum 2 sinusoids of different parameters
cr(c(1, 2), c(2, 10), c(0, -pi/3), N=200, type="l")


# store the above to a vector and overlay with noise
v = cr(c(1, 2), c(2, 10), c(0, -pi/3), N=200, type="l", values=TRUE)
r = runif(200, -3, 3)
v = v+r
plot(0:199, v, type="l")


# 100 points of a 50 Hz sinusoid with a 4 Hz bandwidth 
# at a sampling frequency of 200 Hz
cr(k=50, bw=4, samfreq=2000, N=100)

# the same but shift the y-axis by +4 (d.c. offset=+4)
cr(const=4, k=50, bw=4, samfreq=2000, N=100)

# sinusoid multiplied by a decaying exponential (same effect as bandwidth)
cr(expon=-0.95,  N=200, type="l")

Description

Creates an empty emuDB in the target directory specified

Usage

create_emuDB(
  name,
  targetDir,
  mediaFileExtension = "wav",
  store = TRUE,
  verbose = TRUE
)

Arguments

Details

Creates a new directory [name]_emuDB in targetDir. By default the emuDB is created in the R session, written to the filesystem and then purged from the R session.

Examples

## Not run: 
# create empty emuDB in folder provided by tempdir()
create_emuDB(name = "myNewEmuDB", 
             targetDir = tempdir())

## End(Not run)

Description

Create a folder within the folder specified by the dir argument called emuR_demoData. This folder contains the folders:

• ae_emuDB: Containing an emuDB that adheres to the new format specification (as expected by the load_emuDB function). See vignette(emuDB) for more information on this database format.

• BPF_collection: Containing a BAS Partitur Format (BPF) file collection (as expected by the convert_BPFCollection function)

• legacy_ae: Containing a legacyEmuDB (as expected by the convert_legacyEmuDB function)

• TextGrid_collection: Containing a TextGrid file collection (as expected from the convert_TextGridCollection function)

Usage

create_emuRdemoData(dir = tempdir(), precache = FALSE)

Arguments

Examples

## Not run: 

# create demo data directory in directory
# provided by the tempdir function
create_emuRdemoData(dir = tempdir())

## End(Not run)

Description

Joins emuRsegs and trackdata objects to create an emuRtrackdata object that is a sub-class of a data.frame object. This object can be viewed as a flat version of a trackdata object that also contains all the information of a emuRsegs object. It is meant to ease integration with other packages as it is based on the well known data.frame object.

Usage

create_emuRtrackdata(sl, td)

Arguments

Value

emuRtrackdata object

Examples

## Not run: 

##################################
# prerequisite: loaded ae emuDB 
# (see ?load_emuDB for more information)

# query emuDB (to get object of class emuRsegs)
sl = query(emuDBhandle = ae, 
           query = "Phonetic == i:")
           
# get formats for SEGMENTs in sl (to get object of class trackdata)
td = get_trackdata(emuDBhandle = ae, 
                   seglist = sl,
                   onTheFlyFunctionName = "forest")

# create emuRtrackdata object
create_emuRtrackdata(sl = sl, td = td)


## End(Not run)

Description

Create annotation items programmatically on a single level. You have to pass in a data frame, called itemsToCreate, describing the new items. The required columns depend on the type of the level (ITEM, EVENT, or SEGMENT).

This function belongs to emuR’s CRUD family of functions, which let the user manipulate items programmatically:

• Create items (create_itemsInLevel)

• Read items (query)

• Update items (update_itemsInLevel)

• Delete items (delete_itemsInLevel))

Usage

create_itemsInLevel(
  emuDBhandle,
  itemsToCreate,
  calculateEndTimeForSegments = TRUE,
  allowGapsAndOverlaps = FALSE,
  rewriteAllAnnots = TRUE,
  verbose = TRUE
)

Arguments

Details

This function creates new annotation items on an existing level, in existing bundles.

Regardless of the type of level you are creating items on, your input data frame itemsToCreate must describe your new items by specifying the columns session, bundle, level, attribute and labels. level must have the same value for all rows, as we can only create items on one level at a time.

attribute must also have the same value for all rows, and it must be an existing attribute that belongs to the level.

A major use case for this function is to obtain a segment list using query, modify the segment list and feed it to this function. That is why the column labels has a plural name: segment lists also have a column labels and not label. The same is true for the sequence index columns introduced below.

Creating new items works differently depending on the level type. The three types are explained in the following sections.

Levels of type ITEM

In addition to the columns that are always required, ITEM-typed levels require a column with a sequence index to be present in the itemsToCreate data frame. Its name must be start_item_seq_idx. This name was chosen instead of sequence_index because it is present as a column name in segment lists obtained with query. That makes it easer to use a segment list as input to create_itemsInLevel().

Along the time axis, there can be multiple annotation items on every level. Their order within the level is given by their sequence index. All existing items have a natural-valued sequence index and there are no gaps in the sequences (i.e. if a level contains N annotation items, they are indexed 1..N).

Any newly created item must be given a sequence index. The sequence index may be real-valued (it will automatically be replaced with a natural value). To prepend the new item to the existing ones, pass a value lower than one. To append it to the existing items, you can either pass NA or any value that you know is greater than N (the number of existing items in that level). It does not need to be exactly N+1. To place the new item between two existing ones, use any real value between the sequence indexes of the existing neighbors.

If you are appending multiple items at the same time, every sequence index (including NA) can only be used once per session/bundle/level combination (because session/bundle/level/sequence index are the unique identifier of an item).

After creating the items, all sequence indexes (which may now be real-valued, natural-valued or NA) are sorted in ascending order and then replaced with the values 1..N, where N is the number of items on that level. While sorting, NA values are placed at the end.

Levels of type EVENT

In addition to the columns that are always required, EVENT-typed levels require a column with the time of the event to be present in the itemsToCreate data frame. Its name must be start. This name was chosen because it is present as a column name in segment lists obtained with query. That makes it easer to use a segment list as input to create_itemsInLevel(). The end column in segment lists is 0 for EVENT-typed levels.

The start column must be given in milliseconds.

You cannot create an EVENT item at a point on the time axis where another item already exists on the same level. If you specify such an event, the entire function will fail.

Levels of type SEGMENT

You can only create SEGMENT-typed items in bundles where the respective level is empty.

In addition to the columns that are always required, SEGMENT-typed levels require the column start to be present in the itemsToCreate data frame, representing the start time of the segment. It must be given in milliseconds.

Segments also need to have an end, and there are two strategies to determine the end. Either, you explicitly provide an end column in the itemsToCreate data frame. It must be given in milliseconds. If you do that, you have to specify the calculateEndTimeForSegments parameter as FALSE.

Alternatively, you can leave calculateEndTimeForSegments at TRUE (which is the default) and provide your itemsToCreate data frame without an end column. In that case, the end time will be aligned to the next neighbor’s start time. The end time of the last segment will be aligned with the end of the annotated media file.

Description

create links between items

Usage

create_links(emuDBhandle, links, rewriteAllAnnots = TRUE, verbose = TRUE)

Arguments

Description

Create spectrogram image as raster

Usage

create_spectrogram_image_as_raster(
  audioFilePath,
  begin = 0,
  end = 0,
  windowSizeInSecs = 0.01,
  alpha = 0.16,
  lowerFreq = 0,
  upperFreq = 5000,
  window = "GAUSS",
  dynRangeInDB = 70,
  audioChannel = 1,
  preEmphasisFilterFactor = 0.97,
  invert = FALSE
)

Arguments

Value

a image raster object

Description

A digital sinusoid is derived the movement of a point around a circle. The function shows the relationship between the two for various parameter settings.

Usage

crplot(
  A = 1,
  k = 1,
  p = 0,
  N = 16,
  const = NULL,
  figsize = 8,
  npoints = 500,
  col = 1,
  cplot = TRUE,
  splot = TRUE,
  numplot = TRUE,
  axes = TRUE,
  incircle = TRUE,
  arrow = TRUE,
  linetype = 1,
  textplot = NULL,
  lineplot = NULL,
  ylab = "Amplitude",
  super = NULL,
  xaxlab = NULL,
  type = "b",
  xlab = "Time (number of points)",
  fconst = 3.5/3.1,
  pointconst = 1.2
)

Arguments

Author(s)

Jonathan Harrington

References

Harrington, J, & Cassidy, S. 1999. Techniques in Speech Acoustics. Kluwer

See Also

cr

Examples

crplot()
# sine wave
crplot(p=-pi/2)

crplot(k=3)

# aliasing
crplot(k=15)

Description

Given an Emu trackdata object, dapply will apply a given function to the data corresponding to each segment of data. The result is a new trackdata object.

Usage

dapply(trackdata, fun, ...)

Arguments

Details

dapply can be used to apply an arbitrary function to trackdata extracted from an Emu database. It can be used for example to smooth the data (see dsmooth) or differentiate it (see ddiff).

Trackdata is made up of three components: a matrix of data $data, a matrix of indexes ($index) and a matrix of segment times ($ftime). The indexes contain the start and end rows for each segment in the trackdata, the time matrix contains the start and end times of each data segment.

The function fun supplied to dapply should take one matrix of data (corresponding to one segment) and a vector of two times being the start and end of the data. It should return a modified data matrix, which can have any number of rows or columns, and a new pair of start and end times. The new start and end times are necessary because the operation applied might shorten or interpolate the data and hence change the times corresponding to the first and last rows of data.

Value

An Emu trackdata object with components:

See Also

dsmooth ddiff

Examples

data(dip)
## formant data of the first segment in segment list dip
fm <- dip.fdat[1]

testfun <- function(data, ftime, n) {
  ## return only the first n rows of data
  ## doesn't check to see if there really are n rows...
  newdata <- data[1:n,]
  ## calculate a new end time
  interval <- (ftime[2]-ftime[1])/nrow(data)
  ftime[2] <- ftime[1] + interval*n
  ## now return the required list 
  return( list( data=newdata, ftime=ftime ) )
}

fm.first3 <- dapply( fm, testfun, 3 )
fm.first10 <- dapply( fm, testfun, 10 )

Description

The function can be used to rescale a spectrum to a dB value at a particular frequency - for example, to rescale the spectrum so that 3000 Hz has 0 dB and all other values are shifted in relation to this.

Usage

dbnorm(specdata, f = 0, db = 0)

Arguments

Value

An object of the same class with rescaled dB values. The default is to rescale the dB-values of the spectrum to 0 dB at 0 Hz.

Author(s)

Jonathan Harrington

See Also

dbtopower plot.spectral

Examples

# normalise to - 40 dB at 1500 Hz
res = dbnorm(e.dft, 1500, 0)
# compare the two
ylim = range(c(res, e.dft))
plot(e.dft, ylim=ylim, type="l")
oldpar = par(new=TRUE)
plot(res, ylim=ylim, type="l", col=2)

par(oldpar)

Description

The function converts from decibels to a linear scale

Usage

dbtopower(specdata, const = 10, base = 10, inv = FALSE)

Arguments

Details

The function returns base$\mbox{\textasciicircum}$(specdata/const) if inv=FALSE, otherwise, const * log(dat, base=base). If the object to which this function is applied is of class 'trackdata' then this function is applied to $data.

Value

An object of the same class.

Author(s)

Jonathan Harrington

See Also

dbtopower plot.spectral

Examples

# convert 10 dB to a power ratio
vec = dbtopower(10)
# convert dB-data to a power ratio and back to decibels
res = dbtopower(vowlax.dft.5)
res = dbtopower(res, inv=TRUE)

Description

Obtain the coefficients of the discrete cosine transformation (DCTRUE).

Usage

dct(data, m = NULL, fit = FALSE)

Arguments

Details

The function calculates the DCT coefficients for any vector or single-columned matrix. The function can also be used to obtain a smoothed trajectory of the input data by summing the cosine waves derived from the first few DCT coefficients.

The algorithm first reflects the input signal about the last data point, N. Thus if the input signal vec if of length N, the algorithm creates a vector c(vec, rev(vec[-c(1,N)])). and the R fft function is applied to this reflected signal. The DCT coefficients are real part of what is returned by fft i.e. the amplitudes of the cosine waves of frequencies k = 0, 1, 2, ...2 *(N-1) radians per sample. The phase is zero in all cases. The amplitudes are calculated in such a way such that if these cosine waves are summed, the original (reflected) signal is reconstructed. What is returned by dct() are the amplitudes of the cosine waves (DCT coefficients) up to a frequency of N radians/sample, i.e. a vector of cosine wave amplitudes that has the same length as the original signal and of frequencies k = 0, 1, 2, ... (N-1). Alternatively, if fit=TRUE, a smoothed signal of the same length as the original signal is obtained based on a summation of the lowest ordered DCT coefficients. This dct() algorithm returns very similar values to DCT() with inv=FALSE written by Catherine Watson and used in Watson & Harrington (1999).

Author(s)

Jonathan Harrington

References

Watson, C. & Harrington, J. (1999). Acoustic evidence for dynamic formant trajectories in Australian English vowels. Journal of the Acoustical Society of America, 106, 458-468.

Zahorian, S., and Jagharghi, A. (1993). Spectral-shape features versus formants as acoustic correlates for vowels, Journal of the Acoustical Society of America, 94, 19661982.

See Also

plafit by

Examples

data(vowlax)
# obtain the first four DCT coefficients 
# (frequencies k = 0, 1, 2, 3) for some 
# first formant frequency data
vec <- vowlax.fdat[1,1]$data
dct(vec, m=4)

# obtain the corresponding smoothed
# trajectory
dct(vec, m=4 , fit=TRUE)

Description

A general purpose tool for extracting data from track objects either at a particular time, or between two times. The times can be values in milliseconds or proportional times between zero (the onset) and one (the offset).

Usage

dcut(
  trackdata,
  left.time,
  right.time,
  single = TRUE,
  average = TRUE,
  prop = FALSE
)

Arguments

Details

This function extracts data from each segment of a trackdata object.

If 'prop=FALSE' the time arguments ('left.time' and 'right.time') are interpreted as millisecond times and each should be a vector with the same length as the number of segments in 'trackdata'. If 'prop=TRUE' the time arguments should be single values between zero (the onset of the segment) and one (the offset).

If 'right.time' is omitted then a single data point corresponding to 'left.time' for each segment is returned.

Value

A trackdata object if both 'left.time' and 'right.time' are specified, otherwise a matrix if 'right.time' is unspecified and the trackdata object has multiple columns of data or a vector if right.time' is unspecified and the trackdata object has a single column of data.

Author(s)

Jonathan Harrington

See Also

get_trackdata, dplot, eplot

Examples

# the data values of the trackdata object at the temporal midpoint
     # (midvals is matrix of F1 and F2 data)
     dip.fdat[1:10]
     midvals <- dcut(dip.fdat, 0.5, prop=TRUE)
     midvals[1:10,]
     
     
     # the data values of the trackdata object between 
     # extending from 20
     # (bet is a trackdata object of F1 and F2 values)
     bet <- dcut(dip.fdat, 0.2, 0.8, prop=TRUE)
     bet[1]
     

     # the data values of the trackdata object at 30 ms after
     # the start time of the trackdata object
     # (time30 is a matrix of F1 and F2 data
     times <- dip.fdat$ftime[,1]+30
     times[1:10]
     time30 <- dcut(dip.fdat, times)
     time30[1:10]
     

     # the data values of the trackdata object 
     # between the  start time and 30 ms after the start  time
     # (int is a trackdata object of F1 and F2 values extending
     # from the start of the diphthongs up to 30 ms after the diphthongs)
     int <- dcut(dip.fdat, dip.fdat$ftime[,1], times)
     int[1]

Description

Differentiates a list, as returned by track, to the nth order, readjusting the index and ftime values each time.

Usage

ddiff(dataset, n = 1, smoothing = TRUE)

Arguments

Author(s)

Jonathan Harrington

Description

Delete annotation items programmatically. You have to pass in a data frame, called itemsToDelete, describing these items. The required columns are described below.

This function belongs to emuR’s CRUD family of functions, which let the user manipulate items programmatically:

• Create items (create_itemsInLevel)

• Read items (query)

• Update items (update_itemsInLevel)

• Delete items (delete_itemsInLevel))

Usage

delete_itemsInLevel(
  emuDBhandle,
  itemsToDelete,
  sayYes = FALSE,
  rewriteAllAnnots = TRUE,
  verbose = TRUE
)

Arguments

Details

This function deletes annotation items from existing levels. Your input data frame itemsToDelete must describe the items by specifying the columns session, bundle, and start_item_id.

Be careful with this function: You can use it to create problematic situations, for example gaps in the annotation levels, and the function currently has no checks to prevent this. Instead, you need to explicitly confirm that you are aware of this, either by setting sayYes to TRUE or by interactively responding yes to the prompt this function presents.

A major use case for this function is to obtain a segment list using query, possibly modify the segment list and feed it to this function. That is why the column start_item_id is not called item_id: segment lists include the former column name, not the latter.

Description

Segment list of the demo database that is part of the Emu system. It is the result of a database query, that searched all segments at level Phonetic.

Format

First Column labels Second start time of the segment Third end time of the segment Fourth utterance name of the utterance the segment was found

Details

A segment list is created via query.

See Also

demo.vowels segmentlist

Description

A track list of the demo database that is part of the Emu system. It is the result of get F0 data for the segment list demo.vowels (see data(demo.vowels)).

Format

An object with $index, $ftime and $data

index: a two columned matrix with the range of the $data rows that belong to the segment ftime: a two columned matrix with the times marks of the segment data: a one columned matrix with the F0 values

Details

A track list is created via the get_trackdata function.

See Also

demo.all.rms segmentlist trackdata

Description

A track list of the demo database that is part of the Emu system. It is the result of get fm data for the segment list demo.vowels (see data(demo.vowels)).

Format

index: a two columned matrix with the range of the $data rows that belong to the segment ftime: a two columned matrix with the times marks of the segment data: a three columned matrix with the formant values of the first three formants for each segment

Details

A track list is created via the get_trackdata function.

See Also

demo.all.rms segmentlist trackdata

Description

A track list of the demo database that is part of the Emu system. It is the result of get rms data for the segment list demo.all (data(demo.all)).

Format

A object with $index, $ftime and $data

index: a two columned matrix with the range of the $data rows that belong to the segment ftime: a two columned matrix with the times marks of the segment data: a vector with the rms data

Details

A track list is created via the get_trackdata function.

See Also

demo.vowels.fm segmentlist trackdata

Description

Segment list of the demo database that is part of the Emu system. It is the result of a database query, that searched all vowel segments at level Phonetic.

Format

First Column labels Second start time of the segment Third end time of the segment Fourth utterance name of the utterance the segment was found

Details

A segment list is created via query.

See Also

demo.all segmentlist

Description

A track list of the demo database that is part of the Emu system. It is the result of get F0 data for the segment list demo.vowels (see data(demo.vowels)).

Format

An object with $index, $ftime and $data

index: a two columned matrix with the range of the $data rows that belong to the segment ftime: a two columned matrix with the times marks of the segment data: a one columned matrix with the F0 values

Details

A track list is created via the get_trackdata function.

See Also

demo.all.rms segmentlist trackdata

Description

A track list of the demo database that is part of the Emu system. It is the result of get fm data for the segment list demo.vowels (see data(demo.vowels)).

Format

index: a two columned matrix with the range of the $data rows that belong to the segment ftime: a two columned matrix with the times marks of the segment data: a three columned matrix with the formant values of the first three formants for each segment

Details

A track list is created via the get_trackdata function.

See Also

demo.all.rms segmentlist trackdata

Description

A function that cuts up trackdata either at a proportional time or proportionally between two times. It is a subsidiary function of dplot()

Usage

dextract(dataset, start, end)

Arguments

Value

If both start and end are specified, a trackdata object is returned, otherwise a vector if the original trackdata is one-dimensional and the end argument is not used, or a matrix if the original trackdata has more than one dimension and the end argument is not used

Author(s)

Jonathan Harrington

See Also

dcut

Examples

data(demo.vowels.f0)
data(demo.vowels.fm)

form = demo.vowels.fm
# get the formants at the midpoint: f50 is a matrix
# same as dcut(form, .5, prop=TRUE)
f50 = dextract(form, 0.5)
# get the formants between the 25% and 75% time points
# fcut is a trackdata object
# same as dcut(form, .25, .75, prop=TRUE)
fcut = dextract(form, 0.25, 0.75)
# get  F0 at the midpoint. fzero50 is a vector
# same as dcut(fzero, .5, prop=TRUE)
fzero = demo.vowels.f0
fzero50 = dextract(fzero, 0.5)

Description

The function returns the dimension attributes of a track data object.

Usage

## S3 method for class 'trackdata'
dim(x)

Arguments

Details

The function returns the dimension attributes of a track data object as the number of segments x number of tracks. c(nrow(x$index), ncol(x$data))

Author(s)

Jonathan Harrington

Examples

#isol.fdat is the formant track of the segment list isol

   #write out the dimension of the track data object 
   dim(isol.fdat)

   #because there are 13 segments
   isol.fdat$ftime

   #and there are 4 rows for each segment (see here for the first segment)
   isol.fdat$data[1,]

Description

returns dimension names of trackdata objects

Usage

## S3 method for class 'trackdata'
dimnames(x)

Arguments

Description

An EMU dataset

Format

segmentlist

Description

An EMU dataset

Format

trackdata object

Description

An EMU dataset

Format

vector of phoneme lables

Description

An EMU dataset

Format

vector of speaker labels

Description

A general purpose routine for plotting EMU-trackdata on a single plot. Tracks can be aligned at an arbitrary position, length normalised or averaged. The plots can be colour-coded for different category types. DEPRECATED as this function does not play well with with the new resultType = "tibble" of get_trackdata(). See https://ips-lmu.github.io/The-EMU-SDMS-Manual/recipe-plottingSnippets.html for an alternative plotting routines using ggplot2.

Usage

dplot(
  x,
  labs = NULL,
  offset = 0,
  prop = TRUE,
  average = FALSE,
  xlim = NULL,
  ylim = NULL,
  lty = FALSE,
  normalise = FALSE,
  colour = TRUE,
  lwd = NULL,
  pch = NULL,
  legend = "topright",
  axes = TRUE,
  type = "l",
  n = 20,
  ...
)

Arguments

Author(s)

Jonathan Harrington

See Also

dcut get_trackdata

Examples

# Plot of column 1 (which happens to be the 1st formant) of an EMU-trackdata object
   dplot(dip.fdat[,1])
	

   # As above but only observations 1 to 5
   dplot(dip.fdat[1:5,1])
	

   #  column 2 (which happens to be of the second formant) and colour-coded
   # for each label-type
   dplot(dip.fdat[,2], dip.l)
	

   # put the legend bottom left
   dplot(dip.fdat[,2], dip.l, legend="bottomleft")
	

   # as above with no legend and averaged per category
   dplot(dip.fdat[,2], dip.l, legend=FALSE, average=TRUE)
	

   # both formants averaged
   dplot(dip.fdat[,1:2], dip.l, average=TRUE)
	

   # F2 only with linear-time normalisation
   dplot(dip.fdat[,2], dip.l, norm=TRUE)
	

   # linear time-normalisation, both formants and averaged
   dplot(dip.fdat[,1:2], dip.l, norm=TRUE, average=TRUE)
	

   # synchronise at the temporal midpoint before averaging, F2 only
   dplot(dip.fdat[,2], dip.l, offset=0.5, average=TRUE)
	

   # synchronise 60 ms before the diphthong offset
   dplot(dip.fdat[,2], dip.l, offset=dip.fdat$ftime[,2]-60, prop=FALSE)
	

   # as above averaged, no colour with linetype, 
# different plot symbols double line thickness in the range between +- 20 ms
   dplot(dip.fdat[,2], dip.l, offset=dip.fdat$ftime[,2]-60, prop=FALSE,
   average=TRUE, colour=FALSE, lty=TRUE, pch=1:3, lwd =2, type="b", xlim=c(-20, 20))

Description

Smooths each dataset in a trackdata object using a running mean smoother.

Usage

dsmooth(dataset)

Arguments

Details

This function uses the dapply function to apply smooth to the data for each segment.

Value

The result of applying the smooth function to each column of the data for each segment in the trackdata object.

See Also

smooth, dapply

Description

Duplicate level of emuDB including all of its items and its various attributeDefinitions. If the duplicateLinks variable is set to TRUE all the links to and from the original items are duplicated.

Usage

duplicate_level(
  emuDBhandle,
  levelName,
  duplicateLevelName,
  duplicateLinks = TRUE,
  linkDuplicates = FALSE,
  linkDefType = "ONE_TO_ONE",
  verbose = TRUE
)

Arguments

See Also

load_emuDB

Examples

## Not run: 

##################################
# prerequisite: loaded ae emuDB 
# (see ?load_emuDB for more information)

# duplicate Phonetic level
duplicate_level(ae, levelName = "Phonetic",
                    duplicateLevelName = "Phonetic2")


## End(Not run)

Description

calculates durations

Usage

dur(x)

Arguments

Description

An EMU dataset

Format

spectral vector

Description

Calculates ellipse coordinates for eplot

Usage

ellipse(x, y, rx, ry, orient, incr = 360/100)

Arguments

Value

A matrix of x and y coordinates for the ellipse.

See Also

eplot

Description

An emuR segment list is a list of segment descriptors. Each segment descriptor describes a sequence of annotation elements. The list is usually a result of an emuDB query using function query.

Format

Attributed data.frame, one row per segment descriptor.

Data frame columns are:

• labels: sequenced labels of segment concatenated by '->'

• start: onset time in milliseconds

• end: offset time in milliseconds

• session: session name

• bundle: bundle name

• level: level name

• type: type of "segment" row: 'ITEM': symbolic item, 'EVENT': event item, 'SEGMENT': segment

Additional hidden columns:

• utts: utterance name (for compatibility to emusegs class)

• db_uuid: UUID of emuDB

• startItemID: item ID of first element of sequence

• endItemID: item ID of last element of sequence

• sampleStart: start sample position

• sampleEnd: end sample position

• sampleRate: sample rate

Attributes:

• database: name of emuDB

• query: Query string

• type: type ('segment' or 'event') (for compatibility to emusegs class)

Details

Each row shows the annotation label sequence, the start and end position in time, session and bundle names, level name and type. Additionally the row contains the UUID of the emuDB, the ID's of start and end elements and the corresponding start and end position as sample count and the sample rate. These columns are not printed by default. The print method of emuRsegs hides them. To print all columns of a segment list object use the print method of data.frame. For example to print all columns of an emuRsegs segmentlist sl type: print.data.frame(sl) Though the segment descriptors have references to the annotations, the label and sample/time position information is not updated if any of them change. The values of the segment list may get invalid if the the database is modified. A segment may consist only of one single element, in this case start and end ID are equal. An emuR segment list is the default result of query and can be used to get track data using get_trackdata. The emuRsegs class inherits emusegs and hence data.frame

See Also

query,get_trackdata,emusegs

Description

A emuR track data object is the result of get_trackdata if the resultType parameter is set to "emuRtrackdata" or the result of an explicit call to create_emuRtrackdata. Compared to the trackdata object it is a sub-class of a data.frame which is meant to ease integration with other packages for further processing. It can be viewed as an amalgamation of a emuRsegs and a trackdata object as it contains the information stored in both objects.

Format

The data.frame has the following columns:

$sl_rowIdx

column to indicate emuRsegs row index that the value belongs to

$labels - $sampleRate

duplicated information of emuRsegs row entries

$times_rel

relative time stamps of sample values in milliseconds

$times_orig

absolute time stamps of sample values in milliseconds

$T1 - $TN

actual data values (e.g. formant values / F0 values / DFT values / ...)

Note that $labels - $sampleRate as well as $T1 - $TN (where the N in TN is to be read as the n-th T value) refer to multiple columns of the object.

Methods

The following methods are implemented for emuRtrackdata objects:

cut

Function to extract a emuRtrackdata object from an emuRtrackdata at a single time point or between two times

See Also

get_trackdata, create_emuRtrackdata

trackdata

Description

An EMU dataset

Format

segmentlist

Description

An EMU dataset

Format

trackdata object

Description

An EMU dataset

Format

vector of phonetic labels

Description

An EMU dataset

Format

vector of word labels

Description

epgai(), epgci(), epgdi() return the anteriority index, the centrality index, the dorsopalatal index respectively as a trackdata object or a vector

Usage

epgai(epgdata, weights = c(1, 9, 81, 729, 4921))

Arguments

Details

These are exact implementations of the formulae for calculating the EPG anteriority, EPG centrality, and EPG dorsopalatal indices as described in Recasens & Pallares (2001).

Value

These functions return a trackdata object if they are applied to an eight-columned EPG-compressed trackdata object, otherwise a one-columned matrix.

Author(s)

Jonathan Harrington

References

GIBBON, F. AND NICOLAIDIS, K. (1999). Palatography. In W.J. Hardcastle & N. Hewlett (eds). Coarticulation. (pp. 229-245). Cambridge University Press: Cambridge.

RECASENS, D. & PALLARES, M. (2001) Coarticulation, assimilation and blending in Catalan consonant clusters. Journal of Phonetics, 29, 273-301.

See Also

epgcog epggs palate

Examples

#  Anteriority index: trackdata
ai <- epgai(coutts.epg)
#  Dorsopalatal index, one-columned matrix
di <- epgdi(dcut(coutts.epg, 0.5, prop=TRUE))
# Next to examples: Centrality  index, one-columed matrix
ci <- epgci(palate(coutts.epg))
ci <- epgci(palate(dcut(coutts.epg, 0.5, prop=TRUE)))

Description

Calculate the centre of gravity in palatographic data.

Usage

epgcog(
  epgdata,
  weights = seq(7.5, 0.5, by = -1),
  rows = 1:8,
  columns = 1:8,
  row1 = NULL
)

Arguments

Details

The centre of gravity is a key function in palatographic research and gives an value per palate that is indicative of the overall location of contacts along the anterior-posterior dimension. The formula is an implementation of the ones discussed in Hardcastle et al. (1991), Gibbon et al (1993), and Gibbon & Nicolaidis (1999).

Value

These functions return a trackdata object if they are applied to an eight-columned EPG-compressed trackdata object, otherwise a one-columned matrix.

Author(s)

Jonathan Harrington

References

GIBBON, F., HARDCASTLE, W. and NICOLAIDIS, K. (1993) Temporal and spatial aspects of lingual coarticulation in /kl/ sequences: a cross-linguistic investigation. Language & Speech, 36, 26t1-277.

GIBBON, F. AND NICOLAIDIS, K. (1999). Palatography. In W.J. Hardcastle & N. Hewlett (eds). Coarticulation. (pp. 229-245). Cambridge University Press: Cambridge.

HARDCASTLE, W, GIBBON, F. and NICOLAIDIS, K. (1991) EPG data reduction methods and their implications for studies of lingual coarticulation. Journal of Phonetics, 19, 251-266.

See Also

epgai epgsum palate

Examples

#  COG: trackdata
cog <- epgcog(coutts.epg)
#  cog, one-columned matrix
cog <- epgcog(dcut(coutts.epg, 0.5, prop=TRUE))
# posterior cog for Fig. 10.5, p. 239 in Gibbon & Nicolaidis (1999)
r = array(0, c(8, 8, 2))
r[6,c(1, 8),1] <- 1
r[7,c(1, 2, 7, 8), 1] <- 1
r[8, ,1] <- 1
r[4, c(1, 2, 8), 2] <- 1
r[5, c(1, 2, 7, 8), 2] <- 1
r[6, c(1, 2, 3, 7, 8), 2] <- 1
r[7:8, , 2] = 1
class(r) <- "EPG"
epgcog(r, rows=5:8, columns=3:6)

Description

The function plots a grey-scale image of palatographic data such that the greyness in cell r, c is in proportion to the frequency of contacts in cells of row r and columns c of all palatograms in the object passed to this function.

Usage

epggs(
  epgdata,
  gscale = 100,
  gridlines = TRUE,
  gridcol = "gray",
  gridlty = 1,
  axes = TRUE,
  xlab = "",
  ylab = "",
  ...
)

Arguments

Details

The function plots a grey-scale image of up to 62 values arranged over an 8 x 8 grid with columns 1 and 8 unfilled for row 1. If cell row r column c is contacted for all palatograms in the object that is passed to this function, the corresponding cell is black; if none of of the cells in row r column c are contacted, then the cell is white (unfilled).

Author(s)

Jonathan Harrington

See Also

epgai epgcog epgplot palate

Examples

# greyscale image across the first two segments 'just relax'
# with title
epggs(coutts.epg[1:2,], main="just relax")

# as above but with dotted gridlines in blue
epggs(coutts.epg[1:2,], main="just relax", gridlty=2, gridcol="blue")

# as the first example, but with greyscale set to 2
epggs(coutts.epg[1:2,], 2, main="just relax")

# get palatograms for "S" from the polhom.epg database
temp = polhom.l == "S"
# greyscale image of all "S" segments at their temporal midpoint
epggs(dcut(polhom.epg[temp,], 0.5, prop=TRUE))

# greyscale image of all "S" segments from their onset to offset
epggs(polhom.epg[temp,])

# the same but derived from palates
p <- palate(polhom.epg[temp,])
epggs(p)

Description

Function to plot palatograms from EPG compressed objects or from a 3D-palatographic array that is output from palate().

Usage

epgplot(
  epgdata,
  select = NULL,
  numbering = "times",
  gridlines = TRUE,
  mfrow = NULL,
  col = 1,
  mar = c(0.8, 0.1, 0.8, 0.1),
  xlim = NULL
)

Arguments

Details

The function plots 62 values arranged over an 8 x 8 grid with columns 1 and 8 unfilled for row 1. When there is a contact (1), the corresponding rectangle of the grid is filled otherwise the rectangle is empty.

Author(s)

Jonathan Harrington

See Also

epgai epgcog epggs palate

Examples

epgplot(polhom.epg[10,])

# as above but between times 1295 ms and 1330 ms
epgplot(polhom.epg[10,], xlim=c(1295, 1330))

# the same as above, but the data is first
# converted to a 3D palatographic array
p <- palate(polhom.epg[10,])
epgplot(p, xlim=c(1295, 1330))

# plot palatograms 2 and 8
epgplot(p[,,c(2, 8)])

# as above but
# no gridlines, different colour, numbering rather than times
epgplot(p[,,c(2, 8)], gridlines=FALSE, col="pink", numbering=TRUE)

# as above but with a user-specified title

epgplot(p[,,c(2, 8)], gridlines=FALSE, col="pink", numbering=c("s1", "s2"))

# plot the palatograms in the second
# segment of coutts.epg that are closest in time
# to 16377 ms and 16633 ms
epgplot(coutts.epg[2,], c(16377, 16633))

Description

The function calculates EPG contact profiles, i.e. sums active or inactive electrodes optionally by row and/or column in palatographic data.

Usage

epgsum(
  epgdata,
  profile = c(1, 3),
  inactive = FALSE,
  rows = 1:8,
  columns = 1:8,
  trackname = "EPG-sum"
)

Arguments

Details

Contact profiles are standard tools in electropalatographic analysis. See e.g., Byrd (1996) for details.

Value

These functions return a trackdata object if they are applied to an eight-columned EPG-compressed trackdata object, otherwise a one-columned matrix.

Author(s)

Jonathan Harrington

References

BYRD, D. (1996). Influences on articulatory timing in consonant sequences. Journal of Phonetics, 24, 209-244.

GIBBON, F. AND NICOLAIDIS, K. (1999). Palatography. In W.J. Hardcastle & N. Hewlett (eds). Coarticulation. (pp. 229-245). Cambridge University Press: Cambridge.

See Also

epgai epgcog epggs palate

Examples

# Trackdata object of the sum of contacts in the 1st segment of polhom.epg
epgsum(polhom.epg[1,])
# as above, but the summation is in rows 1-3 only.
epgsum(polhom.epg[1,], rows=c(1:3))
# as epgsum(polhom.epg[1,]), except sum the inactive electrodes in columns 3-6.
epgsum(polhom.epg[1,], columns=3:6, inactive=TRUE)
# Obtain compressed EPG-trackdata object for the 1st four segments of polhom.epg
# at the temporal midpoint
mid <- dcut(polhom.epg[1:4,], .5, prop=TRUE)
# sum of contacts in these four palatograms.
epgsum(mid)
# gives the same result as the previous command.
p <- palate(mid)
# sum the contacts in the palatograms.
epgsum(p)
# as above, but show the separate row summmations. 
epgsum(p, 1)
# as above, but show the separate column summmations. 
epgsum(p, 2)
# sum of the contacts in rows 1-4 showing the separate row summations.
epgsum(p, 1, rows=1:4)
# sum of the contacts in rows 1-4 showing the separate column summations.
epgsum(p, 2, rows=1:4)
# sum of the contacts in columns 3-6  showing the separate row summations.
epgsum(p, 1, columns=3:6)
# sum of the contacts in columns 3-6  showing the separate column summations.
epgsum(p, 2, columns=3:6)

Description

The function plots ellipses for different categories from two-dimensional data. DEPRECATED as this function does not play well with with the new resultType = "tibble" of get_trackdata(). See https://ips-lmu.github.io/The-EMU-SDMS-Manual/recipe-plottingSnippets.html for an alternative plotting routines using ggplot2.

Usage

eplot(
  x,
  labs,
  chars,
  formant = FALSE,
  scaling = "linear",
  prob = 0.95,
  nsdev = NULL,
  dopoints = FALSE,
  doellipse = TRUE,
  centroid = FALSE,
  axes = TRUE,
  xlim,
  ylim,
  col = TRUE,
  lty = FALSE,
  lwd = NULL,
  ...
)

Arguments

Author(s)

Jonathan Harrington, Steve Cassidy

See Also

dcut

Examples

data(vowlax)
   data <- cbind(vowlax.df$F1,vowlax.df$F2)
   phonetic = vowlax.l
   word = vowlax.word

   eplot(data, phonetic)
    
  
   eplot(data, phonetic, form=TRUE, main="F1 x F2 plane", centroid=TRUE)
   eplot(data, phonetic, form=TRUE, main="F1 x F2 plane", dopoints=TRUE)
   eplot(data, phonetic, form=TRUE, main="F1 x F2 plane in Bark", 
         dopoints=TRUE, scaling="bark")
   eplot(data, phonetic, form=TRUE, main="F1 x F2 plane in Bark b/w with linetype", 
         col=FALSE, lty=TRUE, dopoints=TRUE, scaling="bark") 
   eplot(data, phonetic, form=TRUE, main="F1 x F2 plane", 
         doellipse=FALSE, dopoints=TRUE)
   eplot(data, phonetic, form=TRUE, dopoints=TRUE, 
         prob=0.5, main="F1 x F2 plane, 50% confidence intervals")
   eplot(data, phonetic, form=TRUE, dopoints=TRUE, 
         nsdev=2, main="F1 x F2 plane, 2 standard deviations")
   

   temp <- phonetic %in% c("a", "O")
   eplot(data[temp,], phonetic[temp], form=TRUE,  main="F1 x F2 [A] and [O] only", centroid=TRUE)
   

   temp <- phonetic=="O"
   eplot(data[temp,], phonetic[temp], word[temp], form=TRUE, 
         dopoints=TRUE, main="[O] only showing word labels")

Description

Finds the inter-euclidean distance for a data matrix

Usage

euclidean(data, m = 1, n = ncol(data))

Arguments

Value

Calculates the euclidean distance between successive rows of the matrix based on columns m:n.

See Also

steady

Examples

euclidean(cbind(c(1,2,3,4), c(2,3,2,2)))

Description

Labels each data sample

Usage

expand_labels(indvals, labs)

Arguments

Value

Returns a vector of labels, one for each row in the data matrix that corresponds to indvals.

See Also

frames, track

Description

This function exports an emuDB into the BAS Partitur File format, with one BPF file per bundle. The user must pass a list of matching label names and BPF keys. Important: The BPF format does not support explicit hierarchies with more than three levels. Hence, you will probably lose information when exporting complex hierarchies.

Usage

export_BPFCollection(
  handle,
  targetDir,
  extractLevels,
  refLevel = NULL,
  verbose = TRUE,
  newLevels = NULL,
  newLevelClasses = NULL,
  copyAudio = FALSE
)

Arguments

See Also

export_TextGridCollection

Description

Extract the media file (usually .wav file) snippets that correspond to the segments of a segment list (see result of a query) and save them to separate files and write the corresponding labels into a .txt file. Further, the segmentlist is also stored to the target directory (as a .csv file).

Usage

export_seglistToTxtCollection(emuDBhandle, seglist, targetDir)

Arguments

Description

Exports the annotations of an emuDB to a TextGrid collection (.TextGrid and .wav file pairs). To avoid naming conflicts and not to loose the session information, the session structure of the database is kept in place (i.e. the TextGrid collection will have sub-folders that are named as the sessions were). Due to the more complex annotation structure modeling capabilities of the EMU-SDMS system, this export routine has to make several compromises on export which can lead to information loss. So use with caution and at own risk as reimporting the exported data will mean that not all information can be recreated! The main compromises are:

• If a MANY_TO_MANY relationship between two levels is present and two items from the parent level are linked to a single item on the child level, the concatenated using the '->' symbol. An example would be: the annotation items containing the labels 'd' and 'b' of the parent items are merged into a single annotation item and their labels are Phoneme level are linked to 'db' on the Phonetic level. The generated Phoneme tier then has a segment with the start and end times of the 'db' item and contains the labels 'db' (see for example the bundle 0000_ses/msajc010_bndl of the ae_emuDB).

• As annotations can contain gaps (e.g. incomplete hierarchies or orphaned items) and do not have to start at time 0 and be the length of the audio file this export routine pads these gaps with empty segments.

Usage

export_TextGridCollection(
  emuDBhandle,
  targetDir,
  sessionPattern = ".*",
  bundlePattern = ".*",
  attributeDefinitionNames = NULL,
  timeRefSegmentLevel = NULL,
  verbose = TRUE
)

Arguments

See Also

load_emuDB

Examples

## Not run: 

##################################
# prerequisite: loaded ae emuDB 
# (see ?load_emuDB for more information)

## Export all levels
export_TextGridCollection(ae, "/path/2/targetDir")


## End(Not run)

Description

Applies a function to an EMU spectral object.

Usage

fapply(specdata, fun, ..., power = FALSE, powcoeffs = c(10, 10))

Arguments

Details

fapply performs a similar operation to apply except that it is specifically designed for handling EMU spectral objects.

Value

If the output has the same dimensions has the input, then an object of the same dimensionality and class is returned. Otherwise it may be a vector or matrix depending on the function that is applied. ...

Warning

The function can be very slow if applied to a large trackdata object. In this case, it may be faster to use a for-loop with the desired function around $data

Author(s)

Jonathan Harrington

See Also

apply by.trackdata

Examples

# mean value per spectrum, input is a spectral matrix
m <- fapply(vowlax.dft.5, sapply, FUN=mean)
# as above but after converting dB to powers before
# applying the function
m <- fapply(vowlax.dft.5, sapply, FUN=mean, power=TRUE)
# spectral range
r <- fapply(vowlax.dft.5, range)
# spectral moments applied to a trackdata object
# m is a four-dimensional trackdata object
m <- fapply(fric.dft, moments)
# 1st 3 DCT coefficients calculated in a spectral matrix
# d is a 3-columned matrix
d <- fapply(vowlax.dft.5, dct, 3)
# dct-smooth with 10 coefficients. d2 is spectral matrix
d2 <- fapply(vowlax.dft.5, dct, 10, TRUE)
# dct-smooth a trackdata object with 10 coefficients
d3 <- fapply(fric.dft[1:4,], dct, 10, TRUE)

Description

Get frames from trackdata objects

Usage

frames(trackdata)

Arguments

Value

Data frames from the input object.

Author(s)

Jonathan Harrington

See Also

trackdata

Description

Finds the time and position of a data element.

Usage

frames.time(dataset, datanum)

Arguments