readIntensities {ShortRead} | R Documentation

## (Legacy) Read Illumina image intensity files

### Description

`readIntensities` reads image ‘intensity’ files (such as Illumina's `_int.txt` and (optionally) `_nse.txt`) into a single object.

### Usage

    readIntensities(dirPath, pattern=character(0), ...)

### Arguments

`dirPath` | Directory path or other object (e.g., `SolexaPath`) for which methods are defined.
`pattern` | A length 1 character vector representing a regular expression to be combined with `dirPath`, as described below, to match files to be summarized.
`...` | Additional arguments used by methods.

### Details

Additional methods are defined on specific classes, see, e.g., `SolexaPath`.

The `readIntensities,character-method` contains an argument `type` that determines how intensities are parsed. Use the `type` argument to `readIntensities,character-method`, as described below. All `readIntensities,character` methods accepts the folling arguments:

withVariability:

  Include estimates of variability (i.e., from parsing `_nse` files).

verbose:

  Report on progress when starting to read each file.

The supported types and their signatures are:

`type="RtaIntensity"`

  Intensities are read from Illumina `_cif.txt` and `_cnf.txt`-style files. The signature for this method is

  `dirPath, pattern=character(0), ..., type="RtaIntensity", lane=integer(0), cycles=integer(0), cycleIteration=1L, tiles=integer(0), laneName=sprintf("L cycleNames=sprintf("C tileNames=sprintf("s_ posNames=sprintf("s_ withVariability=TRUE, verbose=FALSE`

  lane:

    `integer(1)` identifying the lane in which cycles and tiles are to be processed.

  cycles:

    `integer()` enumerating cycles to be processed.

  cycleIteration:

    `integer(1)` identifying the iteration of the base caller to be summarized

  tiles:

    `integer()` enumerating tile numbers to be summarized.

  laneName, cycleNames, tileNames, posNames:

    `character()` vectors identifying the lane and cycle directories, and the ‘pos’ and tile file names (excluding the ‘.cif’ or ‘.cnf’ extension) to be processed.

  The `dirPath` and `pattern` arguments are combined as `list.files(dirPath, pattern)`, and must identify a single directory. Most uses of this function will focus on a single tile (specified with, e.g., `tiles=1L`); the `laneName`, `cycleNames`, `tileNames`, and `posNames` parameters are designed to work with the default Illumina pipeline and do not normally need to be specified.

`type="IparIntensity"`

  Intensities are read from Solexa `_pos.txt`, `_int.txt.p`, `_nse.txt.p`-style file triplets. The signature for this method is

  `dirPath, pattern=character(0), ..., type="IparIntensity", intExtension="_int.txt.p.gz", nseExtension="_nse.txt.p.gz", posExtension="_pos.txt", withVariability=TRUE, verbose=FALSE`

  Files to be parsed are determined as, e.g., `paste(pattern, intExtension, sep="")`.

`type="SolexaIntensity"`

  Intensities are read from Solexa `_int.txt` and `_nse.txt`-style files. The signature for this method is

  `dirPath, pattern=character(0), ..., type="SolexaIntensity", intExtension="_int.txt", nseExtension="_nse.txt", withVariability=TRUE, verbose=FALSE`

  Files to be parsed are determined as, e.g., `paste(pattern, intExtension, sep="")`.

### Value

An object derived from class `Intensity`.

### Author(s)

Martin Morgan <mtmorgan@fhcrc.org>, Michael Muratet <mmuratet@hudsonalpha.org> (RTA).

### Examples

    fl <- system.file("extdata", package="ShortRead")
    sp <- SolexaPath(fl)
    int <- readIntensities(sp)
    int
    intensity(int)[1,,] 		# one read
    intensity(int)[[1:2,,]]         # two reads, as 'array'
    head(rowMeans(intensity(int)))	# treated as 'array'
    head(pData(readIntensityInfo(int)))

    ## Not run: ## RTA Lane 2, cycles 1:80, cycle iteration 1, tile 3
    int <- readIntensities("Data/Intensities", type="RtaIntensity",
                           lane=2, cycles=1:80, tiles=3)

    ## End(Not run)

[Package ShortRead version 1.50.0 Index]