miga-base 0.3.0.0 → 0.3.0.1

data/utils/enveomics/enveomics.R/R/barplot.R

@@ -0,0 +1,165 @@
+
+enve.barplot <- structure(function(
+    ### Creates nice barplots from tab-delimited tables
+    x,
+    ### Can be either the input data or the path to the file containing the
+    ### table. If it contains the data, it must be a data frame or an object
+    ### coercible to data frame. If it is a path, it must point to a
+    ### tab-delimited file containing header (first row) and row names (first
+    ### column).
+    sizes,
+    ### A numeric vector containing the real size of the samples (columns) in
+    ### the same order of the input table. If set, the values are assumed to be
+    ### 100%, otherwise the sum of the columns is used.
+    top=25,
+    ### Maximum number of categories to display. Any additional categories will
+    ### be listed as "Others".
+    colors.per.group=9,
+    ### Number of categories in the first two saturation groups of colors. The
+    ### third group contains the remaining categories if needed.
+    bars.width=4,
+    ### Width of the barplot with respect to the legend.
+    legend.ncol=1,
+    ### Number of columns in the legend.
+    other.col='#000000',
+    ### Color of the "Others" category.
+    add.trend=FALSE,
+    ### Controls if semi-transparent areas are to be plotted between the bars to
+    ### connect the regions (trend regions).
+    organic.trend=FALSE,
+    ### Controls if the trend regions are to be smoothed (curves). By default,
+    ### trend regions have straight edges. If TRUE, forces add.trend=TRUE.
+    sort.by=median,
+    ### Any function that takes a numeric vector and returns a numeric scalar.
+    ### This function is applied to each row, and the resulting values are used
+    ### to sort the rows (decreasingly). Good options include: sd, min, max,
+    ### mean, median.
+    min.report=101,
+    ### Minimum percentage to report the value in the plot. Any value above 100
+    ### indicates that no values are to be reported.
+    order=NULL,
+    ### Controls how the rows should be ordered. If NULL (default), sort.by is
+    ### applied per row and the results are sorted decreasingly. If NA, no
+    ### sorting is performed, i.e., the original order is respected. If a vector
+    ### is provided, it is assumed to be the custom order to be used (either by
+    ### numeric index or by row names).
+    col,
+    ### Colors to use. If provided, overrides the variables `top` and
+    ### `colors.per.group`, but `other.col` is still used if the vector is
+    ### insufficient for all the rows. An additional palette is available with
+    ### col='coto' (contributed by Luis (Coto) Orellana).
+    ...
+    ### Any additional parameters to be passed to `barplot`.
+    ){
+   
+  # Read input
+  if(is.character(x)){
+    c <- read.table(x, sep='\t', header=TRUE, row.names=1, quote='',
+      comment.char='')
+  }else{
+    c <- as.data.frame(x)
+  }
+  if(missing(sizes)) sizes = colSums(c)
+  p <- c
+  for (i in 1:ncol(c)) p[, i] <- c[, i]*100/sizes[i]
+  if(top > nrow(p)) top = nrow(p)
+
+  # Sort
+  if(is.null(order[1])){
+    p <- p[order(apply(p, 1, sort.by)), ]
+  }else if(is.na(order[1])){
+      
+  }else{
+    p <- p[order, ]
+  }
+  if(organic.trend) add.trend=TRUE
+   
+  # Colors
+  if(is.null(top)) top <- nrow(p)
+  if(missing(col)){
+    color.col <- rainbow(min(colors.per.group, top), s=1, v=4/5)
+    if(top > colors.per.group) color.col <- c(color.col,
+          rainbow(min(colors.per.group*2, top)-colors.per.group, s=3/4, v=3/5))
+    if(top > colors.per.group*2) color.col <- c(color.col,
+          rainbow(top-colors.per.group*2, s=1, v=1.25/4))
+  }else if(length(col)==1 & col=='coto'){
+    color.col <- c("#5BC0EB","#FDE74C","#9BC53D","#E55934","#FA7921","#EF476F",
+                    "#FFD166","#06D6A0","#118AB2","#073B4C","#264653","#2A9D8F",
+                    "#E9C46A","#F4A261","#E76F51")
+    color.col <- head(color.col, n=nrow(p))
+    top <- length(color.col)
+  }else{
+    color.col <- col
+    color.col <- tail(color.col, n=nrow(p))
+    top <- length(color.col)
+  }
+
+  # Plot
+  layout(matrix(1:2, nrow=1), widths=c(bars.width,1))
+  mar <- par('mar')
+  par(mar=c(5,4,4,0)+0.1)
+  mp <- barplot(as.matrix(p),
+    col=rev(c(color.col, rep(other.col, nrow(p)-length(color.col)))),
+    border=NA,space=ifelse(add.trend,ifelse(organic.trend,0.75,0.5),0.2), ...)
+  if(add.trend || min.report < max(p)){
+    color.alpha <- paste(c(substr(color.col, 1, 7), other.col), '40', sep='')
+    if(top < nrow(p)){
+      cf <- colSums(p[1:(nrow(p)-top), ])
+    }else{
+      cf <- rep(0, ncol(p))
+    }
+    for(i in (nrow(p)-top+1):nrow(p)){
+      f <- as.numeric(p[i, ])
+      cf <- as.numeric(cf + f)
+      if(nrow(p)-i < top){
+        if(organic.trend){
+          spc <- 0.5
+          x <- c(mp[1]-spc)
+          y1 <- c(cf[1]-f[1])
+          y2 <- c(cf[1])
+          for(j in 2:ncol(p)){
+            x <- c(x, seq(mp[j-1]+spc, mp[j]-spc, length.out=22))
+            y1 <- c(y1, cf[j-1]-f[j-1],
+                (tanh(seq(-2.5,2.5,length.out=20))/2+.5)*
+                  ((cf[j]-f[j])-(cf[j-1]-f[j-1]))+(cf[j-1]-f[j-1]), cf[j]-f[j])
+            y2 <- c(y2, cf[j-1],
+                (tanh(seq(-2.5,2.5,length.out=20))/2+.5)*
+                  (cf[j]-cf[j-1])+(cf[j-1]), cf[j])
+          }
+          x <- c(x, mp[length(mp)]+spc)
+          y1 <- c(y1, cf[length(cf)]-f[length(f)])
+          y2 <- c(y2, cf[length(cf)])
+          polygon(c(x, rev(x)), c(y1, rev(y2)), col=color.alpha[nrow(p)-i+1],
+              border=NA)
+        }else if(add.trend){
+          x <- rep(mp, each=2)+c(-0.5,0.5)
+          if(add.trend) polygon(c(x, rev(x)),
+              c(rep(cf-f, each=2), rev(rep(cf, each=2))),
+              col=color.alpha[nrow(p)-i+1], border=NA)
+        }
+        text(mp, cf-f/2, ifelse(f>min.report, signif(f, 3), ''), col='white')
+      }
+    }
+  }
+   
+  # Legend
+  par(mar=rep(0,4)+0.1)
+  plot(1, t='n', bty='n', xlab='', ylab='', xaxt='n', yaxt='n')
+  nam <- rownames(p[nrow(p):(nrow(p)-top+1), ])
+  if(top < nrow(p)) nam <- c(nam,
+      paste('Other (',nrow(p)-length(color.col),')', sep=''))
+  legend('center', col=c(color.col, other.col), legend=nam, pch=15, bty='n',
+    pt.cex=2, ncol=legend.ncol)
+  par(mar=mar)
+}, ex=function(){
+  # Load data
+  data("phyla.counts", package="enveomics.R", envir=environment())
+  # Create a barplot sorted by variance with organic trends
+  enve.barplot(phyla.counts, # Counts of phyla in four sites
+    sizes=c(250,100,75,200), # Total sizes of the datasets of each site
+    bars.width=2, # Decrease from default, so the names are fully displayed
+    organic.trend=TRUE, # Nice curvy background
+    sort.by=var # Sort by variance across sites
+  )
+})
+

data/utils/enveomics/enveomics.R/R/cliopts.R

@@ -0,0 +1,119 @@
+enve.cliopts <- function(
+      ### Generates nicely formatted command-line interfaces for
+      ### functions (_closures_ only).
+      fx,
+      ### Function for which the interface should be generated.
+      rd_file,
+      ### (Optional) .Rd file with the standard documentation of the function.
+      positional_arguments,
+      ### (Optional) Number of _positional_ arguments passed to parse_args
+      ### (package:optparse).
+      usage,
+      ### (Optional) Usage passed to OptionParser (package:optparse).
+      mandatory=c(),
+      ### Mandatory arguments.
+      vectorize=c(),
+      ### Arguments of the function to vectorize (comma-delimited). If numeric,
+      ### use also `number`.
+      ignore=c(),
+      ### Arguments of the function to ignore.
+      number=c(),
+      ### Force these arguments as numerics. Useful for numeric
+      ### vectors (see `vectorize`) or arguments with no defaults.
+      defaults=list(),
+      ### Defaults to use instead of the ones provided by the formals.
+      o_desc=list(),
+      ### Descriptions of the options. Help from `rd` is ignored for arguments
+      ### present in this list.
+      p_desc=""
+      ### Description of the function. Help from `rd` is ignored for the
+      ### function description unless this value is an empty string.
+      ){
+   
+   #= Load stuff
+   if(!suppressPackageStartupMessages(
+      requireNamespace("optparse", quietly=TRUE)))
+	 stop("Package 'optparse' is required.")
+   requireNamespace("tools", quietly=TRUE)
+   if(missing(positional_arguments)) positional_arguments <- FALSE
+   if(missing(usage)) usage <- "usage: %prog [options]"
+   
+   #= Get help (if any)
+   if(!missing(rd_file)){
+      rd <- tools::parse_Rd(rd_file)
+      for(i in 1:length(rd)){
+         tag <- attr(rd[[i]],'Rd_tag')
+	 if(tag=="\\description" && p_desc==""){
+	    p_desc <- paste("\n\t",as.character(rd[[i]]),sep='')
+	 }else if(tag=="\\arguments"){
+	    for(j in 1:length(rd[[i]])){
+	       if(length(rd[[i]][[j]])==2){
+		  name <- as.character(rd[[i]][[j]][[1]])
+		  if(length(o_desc[[name]])==1) next
+		  desc <- as.character(rd[[i]][[j]][[2]])
+		  o_desc[[name]] <- paste(gsub("\n","\n\t\t",desc), collapse='')
+	       }
+	    }
+	 }
+      }
+   }
+
+   #= Set options
+   o_i <- 0
+   opts <- list()
+   f <- formals(fx)
+   if(length(defaults)>0){
+      for(i in 1:length(defaults)) f[[names(defaults)[i]]] <- defaults[[i]]
+   }
+   for(i in names(f)){
+      if(i=="..." || i %in% ignore) next
+      o_i <- o_i + 1
+      flag <- gsub("\\.","-",i)
+
+      optopt <- list(help="")
+      if(length(o_desc[[i]])==1) optopt$help <- o_desc[[i]]
+      if(!is.null(f[[i]]) && !suppressWarnings(is.na(f[[i]])) && is.logical(f[[i]])){
+	 optopt$opt_str <- paste(ifelse(f[[i]], "--no-", "--"), flag, sep='')
+	 optopt$action  <- ifelse(f[[i]], "store_false", "store_true")
+      }else{
+	 optopt$opt_str <- paste("--", flag, sep='')
+	 optopt$action  <- "store"
+	 optopt$help <- paste(optopt$help, "\n\t\t[",
+	    ifelse(i %in% mandatory, "** MANDATORY", "default %default"),
+	    ifelse(i %in% vectorize, ", separate values by commas", ""),
+	    "].", sep="")
+      }
+      if(!is.name(f[[i]])){
+	 optopt$default <- f[[i]]
+	 optopt$metavar <- class(f[[i]])
+      }
+      if(i %in% number) optopt$metavar <- "NUMERIC"
+      optopt$dest <- i
+      
+      opts[[o_i]] <- do.call(optparse::make_option, optopt)
+   }
+   opt <- optparse::parse_args(
+      optparse::OptionParser(option_list=opts, description=p_desc, usage=usage),
+      positional_arguments=positional_arguments)
+
+   #= Post-hoc checks
+   if(length(opt[['options']])==0) opt <- list(options=opt, args=c())
+   for(i in mandatory){
+      if(length(opt$options[[i]])==0) stop('Missing mandatory argument: ',i)
+   }
+   for(i in vectorize){
+      if(length(opt$options[[i]])==1)
+	 opt$options[[i]] <- strsplit(opt$options[[i]],",")[[1]]
+   }
+   for(i in number){
+      if(length(opt$options[[i]])>0)
+	 opt$options[[i]] <- as.numeric(opt$options[[i]])
+   }
+   opt$options$help <- NULL
+   
+   return(opt)
+   ### Returns a `list` with keys: `options`, a named list with the values for
+   ### the function's arguments; and `args`, a vector with zero or more strings
+   ### containing the positional arguments.
+}
+

data/utils/enveomics/enveomics.R/R/df2dist.R

@@ -0,0 +1,117 @@
+
+enve.df2dist <- function(
+	### Transform a dataframe (or coercible object, like a table) into a `dist` object.
+	x,
+	### A table (or coercible object) with at least three columns: (1) ID of the object 1,
+	### (2) ID of the object 2, and (3) distance between the two objects.
+	obj1.index=1,
+	### Index of the column containing the ID of the object 1.
+	obj2.index=2,
+	### Index of the column containing the ID of the object 2.
+	dist.index=3,
+	### Index of the column containing the distance.
+	default.d=NA,
+	### Default value (for missing values)
+	max.sim=0
+	### If not-zero, assumes that the values are similarity (not distance)
+	### and this is the maximum similarity (corresponding to distance 0).
+	### Applies transformation: distance = (max.sim - values)/max.sim.
+	){
+   x <- as.data.frame(x);
+   a <- as.character(x[, obj1.index]);
+   b <- as.character(x[, obj2.index]);
+   d <- as.double(x[, dist.index]);
+   if(max.sim!=0) d <- (max.sim - d)/max.sim
+   ids <- unique(c(a,b));
+   m <- matrix(default.d, nrow=length(ids), ncol=length(ids), dimnames=list(ids, ids));
+   diag(m) <- 0.0
+   for(i in 1:nrow(x)){
+      m[a[i], b[i]] <- d[i];
+   }
+   m <- pmin(m, t(m), na.rm=TRUE)
+   return(as.dist(m));
+   ### Returns a `dist` object.
+}
+
+
+
+enve.df2dist.group <- function(
+	### Transform a dataframe (or coercible object, like a table) into a `dist` object, where
+	### there are 1 or more distances between each pair of objects.
+	x,
+	### A dataframe (or coercible object) with at least three columns: (1) ID of the object 1,
+	### (2) ID of the object 2, and (3) distance between the two objects.
+	obj1.index=1,
+	### Index of the column containing the ID of the object 1.
+	obj2.index=2,
+	### Index of the column containing the ID of the object 2.
+	dist.index=3,
+	### Index of the column containing the distance.
+	summary=median,
+	### Function summarizing the different distances between the two objects.
+	empty.rm=TRUE
+	### Remove rows with empty or NA groups
+	){
+   x <- as.data.frame(x);
+   if(empty.rm) x <- x[ !(is.na(x[,obj1.index]) | is.na(x[,obj2.index]) | x[,obj1.index]=='' | x[,obj2.index]==''), ]
+   a <- as.character(x[, obj1.index]);
+   b <- as.character(x[, obj2.index]);
+   d <- as.double(x[, dist.index]);
+   ids <- unique(c(a,b));
+   if(length(ids)<2) return(NA);
+   m <- matrix(NA, nrow=length(ids), ncol=length(ids), dimnames=list(ids, ids));
+   diag(m) <- 0
+   for(i in 2:length(ids)){
+      id.i <- ids[i];
+      for(j in 1:(i-1)){
+	 id.j <- ids[j];
+	 d.ij <- summary(c( d[ a==id.i & b==id.j], d[ b==id.i & a==id.j] ));
+	 m[id.i, id.j] <- d.ij;
+	 m[id.j, id.i] <- d.ij;
+      }
+   }
+   return(as.dist(m));
+   ### Returns a `dist` object.
+}
+
+enve.df2dist.list <- function(
+	### Transform a dataframe (or coercible object, like a table) into a `dist` object.
+	x,
+	### A dataframe (or coercible object) with at least three columns: (1) ID of the object 1,
+	### (2) ID of the object 2, and (3) distance between the two objects.
+	groups,
+	### Named array where the IDs correspond to the object IDs, and the values correspond to
+	### the group.
+	obj1.index=1,
+	### Index of the column containing the ID of the object 1.
+	obj2.index=2,
+	### Index of the column containing the ID of the object 2.
+	dist.index=3,
+	### Index of the column containing the distance.
+	empty.rm=TRUE,
+	### Remove incomplete matrices
+	...
+	### Any other parameters supported by `enve.df2dist.group`.
+	){
+   x <- as.data.frame(x);
+   a <- as.character(x[, obj1.index]);
+   b <- as.character(x[, obj2.index]);
+   d <- as.numeric(x[, dist.index]);
+   ids.all <- unique(c(a,b));
+   l <- list();
+   same_group <- groups[a]==groups[b];
+   same_group <- ifelse(is.na(same_group), FALSE, TRUE);
+   for(group in unique(groups)){
+      ids <- ids.all[ groups[ids.all]==group ];
+      if(length(ids)>1 & group!=""){
+	 x.sub <- x[ same_group & (groups[a]==group) & (groups[b]==group), ]
+	 if(nrow(x.sub)>0){
+	    d.g <- enve.df2dist(x.sub, obj1.index, obj2.index, dist.index, ...);
+	    if(!empty.rm | !any(is.na(d.g))) l[[ group ]] <- d.g;
+	 }
+      }
+   }
+   return(l);
+   ### Returns a `list` of `dist` object.
+}
+

data/utils/enveomics/enveomics.R/R/growthcurve.R

@@ -0,0 +1,263 @@
+#==============> Define S4 classes
+setClass("enve.GrowthCurve",
+  ### Enve-omics representation of fitted growth curves.
+  representation(
+  design  = "array", ##<< Experimental design of the experiment.
+  models  = "list",  ##<< Fitted growth curve models.
+  predict = "list",  ##<< Fitted growth curve values.
+  call='call')       ##<< Call producing this object.
+  ,package='enveomics.R');
+setMethod("$", "enve.GrowthCurve", function(x, name) attr(x, name))
+
+#==============> Define S4 methods
+plot.enve.GrowthCurve <- function
+  ### Plots an `enve.GrowthCurve` object.
+    (x,
+    ### `enve.GrowthCurve` object to plot.
+    col,
+    ### Base colors to use for the different samples. Can be recycled. By
+    ### default, grey for one sample or rainbow colors for more than one.
+    pt.alpha=0.9,
+    ### Color alpha for the observed data points, using `col` as a base.
+    ln.alpha=1.0,
+    ### Color alpha for the fitted growth curve, using `col` as a base.
+    ln.lwd=1,
+    ### Line width for the fitted curve.
+    ln.lty=1,
+    ### Line type for the fitted curve.
+    band.alpha=0.4,
+    ### Color alpha for the confidence interval band of the fitted growth curve,
+    ### using `col` as a base.
+    band.density=NULL,
+    ### Density of the filling pattern in the interval band. If NULL, a solid
+    ### color is used.
+    band.angle=45,
+    ### Angle of the density filling pattern in the interval band. Ignored if
+    ### `band.density` is NULL.
+    xp.alpha=0.5,
+    ### Color alpha for the line connecting individual experiments, using `col`
+    ### as a base.
+    xp.lwd=1,
+    ### Width of line for the experiments.
+    xp.lty=1,
+    ### Type of line for the experiments.
+    pch=19,
+    ### Point character for observed data points.
+    new=TRUE,
+    ### Should a new plot be generated? If FALSE, the existing canvas is used.
+    legend=new,
+    ### Should the plot include a legend? If FALSE, no legend is added. If TRUE,
+    ### a legend is added in the bottom-right corner. Otherwise, a legend is
+    ### added in the position specified as `xy.coords`. 
+    add.params=FALSE,
+    ### Should the legend include the parameters of the fitted model?
+    ...
+    ### Any other graphic parameters.
+  ){
+  
+  # Arguments
+  if(missing(col)){
+    col <-
+      if(length(x$design)==0) grey(0.2)
+      else rainbow(length(x$design), v=3/5, s=3/5)
+  }
+
+  if(new){
+    # Initiate canvas
+    od.fit.max <- max(sapply(x$predict, function(x) max(x[,"upr"])))
+    od.obs.max <- max(sapply(x$models, function(x) max(x$data[,"od"])))
+    opts <- list(...)
+    plot.defaults <- list(xlab="Time", ylab="Density",
+      xlim=range(x$predict[[1]][,"t"]), ylim=c(0, max(od.fit.max, od.obs.max)))
+    for(i in names(plot.defaults)){
+      if(is.null(opts[[i]])) opts[[i]] <- plot.defaults[[i]]
+    }
+    opts[["x"]] <- 1
+    opts[["type"]] <- "n"
+    do.call(plot, opts)
+  }
+
+  # Graphic default
+  pch <- rep(pch, length.out=length(x$design))
+  col <- rep(col, length.out=length(x$design))
+  pt.col   <- enve.col2alpha(col, pt.alpha)
+  ln.col   <- enve.col2alpha(col, ln.alpha)
+  band.col <- enve.col2alpha(col, band.alpha)
+  xp.col   <- enve.col2alpha(col, xp.alpha)
+  band.angle   <- rep(band.angle, length.out=length(x$design))
+  if(!all(is.null(band.density))){
+    band.density <- rep(band.density, length.out=length(x$design))
+  }
+  
+  for(i in 1:length(x$design)){
+    # Observed data
+    d <- x$models[[i]]$data
+    points(d[,"t"], d[,"od"], pch=pch[i], col=pt.col[i])
+    for(j in unique(d[,"replicate"])){
+      sel <- d[,"replicate"]==j
+      lines(d[sel,"t"], d[sel,"od"], col=xp.col[i], lwd=xp.lwd, lty=xp.lty)
+    }
+    # Fitted growth curves
+    if(x$models[[i]]$convInfo$isConv){
+      d <- x$predict[[i]]
+      lines(d[,"t"], d[,"fit"], col=ln.col[i], lwd=ln.lwd, lty=ln.lty)
+      polygon(c(d[,"t"], rev(d[,"t"])), c(d[,"lwr"], rev(d[,"upr"])),
+        border=NA, col=band.col[i], density=band.density[i],
+        angle=band.angle[i])
+    }
+  }
+  
+  if(!all(is.logical(legend)) || legend){
+    if(all(is.logical(legend))) legend <- "bottomright"
+    legend.txt <- names(x$design)
+    if(add.params){
+      for(p in names(coef(x$models[[1]]))){
+        legend.txt <- paste(legend.txt, ", ", p, "=",
+          sapply(x$models, function(x) signif(coef(x)[p],2)) , sep="")
+      }
+    }
+    legend(legend, legend=legend.txt, pch=pch, col=ln.col)
+  }
+}
+
+summary.enve.GrowthCurve <- function(
+    ### Summary of an `enve.GrowthCurve` object.
+    object,
+    ### `enve.GrowthCurve` object.
+    ...
+    ### No additional parameters are currently supported.
+  ){
+
+  x <- object
+  cat('===[ enve.GrowthCurves ]------------------\n')
+  for(i in names(x$design)){
+     cat(i, ':\n', sep='')
+     if(x$models[[i]]$convInfo$isConv){
+       for(j in names(coef(x$models[[i]]))){
+         cat('  - ', j, ' = ', coef(x$models[[i]])[j], '\n', sep='')
+       }
+     }else{
+       cat('  Model didn\'t converge:\n    ',
+         x$models[[i]]$convInfo$stopMessage, '\n', sep='')
+     }
+     cat('  ', nrow(x$models[[i]]$data), ' observations, ',
+       length(unique(x$models[[i]]$data[,"replicate"])), ' replicates.\n',
+       sep='')
+  }
+  cat('------------------------------------------\n')
+  cat('call:',as.character(attr(x,'call')),'\n')
+  cat('------------------------------------------\n')
+}
+
+#==============> Core functions
+enve.growthcurve <- structure(function(
+  ### Calculates growth curves using the logistic growth function.
+    x,
+    ### Data frame (or coercible) containing the observed growth data (e.g.,
+    ### O.D. values). Each column is an independent growth curve and each
+    ### row is a time point. NA's are allowed.
+    times=1:nrow(x),
+    ### Vector with the times at which each row was taken. By default, all
+    ### rows are assumed to be part of constantly periodic measurements.
+    triplicates=FALSE,
+    ### If TRUE, the columns are assumed to be sorted by sample with three
+    ### replicates by sample. It requires a number of columns multiple of 3.
+    design,
+    ### Experimental design of the data. An `array` of mode list with sample
+    ### names as index and the list of column names in each sample as the
+    ### values. By default, each column is assumed to be an independent sample
+    ### if `triplicates` is FALSE, or every three columns are assumed to be a
+    ### sample if `triplicates` is TRUE. In the latter case, samples are
+    ### simply numbered.
+    new.times=seq(min(times), max(times), length.out=length(times)*10),
+    ### Values of time for the fitted curve.
+    level=0.95,
+    ### Confidence (or prediction) interval in the fitted curve.
+    interval=c("confidence","prediction"),
+    ### Type of interval to be calculated for the fitted curve.
+    plot=TRUE,
+    ### Should the growth curve be plotted?
+    FUN=function(t,K,r,P0) K*P0*exp(r*t)/(K+P0*(exp(r*t)-1)),
+    ### Function to fit. By default: logistic growth with paramenters `K`:
+    ### carrying capacity, `r`: intrinsic growth rate, and `P0`: Initial
+    ### population.
+    nls.opt=list(),
+    ### Any additional options passed to `nls`.
+    ...
+    ### Any additional parameters to be passed to `plot.enve.GrowthCurve`.
+  ){
+  
+  # Arguments
+  if(missing(design)){
+    design <-
+      if(triplicates)
+        tapply(colnames(x), colnames(x)[rep(1:(ncol(x)/3)*3-2, each=3)], c,
+          simplify=FALSE)
+      else tapply(colnames(x), colnames(x), c, simplify=FALSE)
+  }
+  mod <- list()
+  fit <- list()
+  interval <- match.arg(interval)
+  enve._growth.fx <- NULL
+  enve._growth.fx <<- FUN
+  
+  for(sample in names(design)){
+    od <- c()
+    for(col in design[[sample]]){
+      od <- c(od, x[,col])
+    }
+    data <- data.frame(t=rep(times, length(design[[sample]])), od=od,
+      replicate=rep(1:length(design[[sample]]), each=length(times)))
+    data <- data[!is.na(data$od),]
+    opts <- nls.opt
+    opts[["data"]] <- data
+    opt.defaults <- list(formula = od ~ enve._growth.fx(t, K, r, P0),
+      algorithm="port", lower=list(P0=1e-16),
+      control=nls.control(warnOnly=TRUE),
+      start=list(
+        K  = 2*max(data$od),
+        r  = length(times)/max(data$t),
+        P0 = min(data$od[data$od>0])
+      ))
+    for(i in names(opt.defaults)){
+      if(is.null(opts[[i]])){
+        opts[[i]] <- opt.defaults[[i]]
+      }
+    }
+    mod[[sample]] <- do.call(nls, opts)
+    fit[[sample]] <- cbind(t=new.times,
+      predFit(mod[[sample]], level=level, interval=interval,
+        newdata=data.frame(t=new.times)))
+  }
+  enve._growth.fx <<- NULL
+  gc <- new("enve.GrowthCurve",
+    design=design, models=mod, predict=fit,
+    call=match.call());
+  if(plot) plot(gc, ...);
+  return(gc)
+  ### Returns an `enve.GrowthCurve` object.
+}, ex=function(){
+  # Load data
+  data("growth.curves", package="enveomics.R", envir=environment())
+  # Generate growth curves with different colors
+  g <- enve.growthcurve(growth.curves[,-1], growth.curves[,1], triplicates=TRUE)
+  # Generate black-and-white growth curves with different symbols
+  plot(g, pch=15:17, col="black", band.density=45, band.angle=c(-45,45,0))
+});
+
+enve.col2alpha <- function(
+    ### Takes a vector of colors and sets the alpha.
+    x,
+    ### A vector of any value base colors.
+    alpha
+    ### Alpha level to set (in the 0-1 range).
+    ){
+  out <- c()
+  for(i in x){
+    opt <- as.list(col2rgb(i)[,1]/256)
+    opt[["alpha"]] = alpha
+    out <- c(out, do.call(rgb, opt))
+  }
+  names(out) <- names(x)
+  return(out)
+}