preprocess               package:Ringo               R Documentation

_P_r_e_p_r_o_c_e_s_s _N_i_m_b_l_e_g_e_n _R_a_w _I_n_t_e_n_s_i_t_i_e_s

_D_e_s_c_r_i_p_t_i_o_n:

     Calls one of various 'limma' functions to transform raw probe
     intensities into (background-corrected) normalized log ratios
     (M-values).

_U_s_a_g_e:

     preprocess(myRG, method = "vsn", returnMAList=FALSE, verbose=TRUE, ...)

_A_r_g_u_m_e_n_t_s:

    myRG: object of class 'RGList'

  method: string; denoting which normalization method to choose

returnMAList: logical; should an MAList object be returned? Default is
          to return an ExpressionSet object.

 verbose: logical; progress output to STDOUT?

     ...: further arguments to be passed on 'normalizeWithinArrays' and
          'normalizeBetweenArrays'

_D_e_t_a_i_l_s:

     The procedure and called 'limma' functions depend on the choice of
     method.

     _l_o_e_s_s First performs background correction of intensity values
          using 'limma''s function 'backgroundCorrect' with
          'method="normexp"' and 'offset=50'. Then calls
          'normalizeWithinArrays'.

     _v_s_n Does not do any background correction, but rather directly
          calls 'normalizeBetweenArrays' with 'method="vsn"'.

     _G_q_u_a_n_t_i_l_e Does not do any background correction, but rather
          directly calls 'normalizeBetweenArrays' with
          'method="Gquantile"'.

     _m_e_d_i_a_n First performs background correction of intensity values
          using 'limma''s function 'backgroundCorrect' with
          'method="normexp"' and 'offset=50'. Then calls
          'normalizeWithinArrays' with 'method="median".'

     _n_i_m_b_l_e_g_e_n Scaling procedure used by Nimblegen. Yields scaled
          log-ratios by a two step procedure: srat = log2(R) - log2(G)
          srat = srat - tukey.biweight(srat)

     _n_o_n_e No normalization of probe intensities, takes raw
          'log2(R)-log2(G)' as component 'M' and '(log2(R)+log2(G))/2'
          as component 'A'; uses 'normalizeWithinArrays' with
          'method="none"'.

_V_a_l_u_e:

     Returns normalized, transformed values as an object of class
     'ExpressionList' or 'MAList'.

_A_u_t_h_o_r(_s):

     Joern Toedling toedling@ebi.ac.uk

_S_e_e _A_l_s_o:

     'backgroundCorrect', 'normalizeWithinArrays',
     'normalizeBetweenArrays', 'malist','ExpressionSet',
     'tukey.biweight'

_E_x_a_m_p_l_e_s:

        exDir <- system.file("exData",package="Ringo")
        exRG <- readNimblegen("example_targets.txt","spottypes.txt",path=exDir)
        exampleX <- preprocess(exRG)
        sampleNames(exampleX) <- 
          make.names(paste(exRG$targets$Cy5,"vs",exRG$targets$Cy3,sep="_"))
        print(exampleX)

        ### compare VSN to NimbleGen's tukey-biweight scaling
        exampleX.NG <- preprocess(exRG, method="nimblegen")
        sampleNames(exampleX.NG) <- sampleNames(exampleX)
        if (interactive())
          corPlot(cbind(exprs(exampleX),exprs(exampleX.NG)),
            grouping=c("VSN normalized","Tukey-biweight scaled"))

