`R/diamondCoordinates.R`

, `R/ggDiamondLayer.R`

, `R/rawDataDiamondLayer.R`

, and 1 more
`basicDiamondplotFunctions.Rd`

These functions are used by `diamondPlot()`

to construct a diamond
plot. It's normally not necessary to call this function directly: instead,
use `meansDiamondPlot()`

, `meanSDtoDiamondPlot()`

, and
`factorLoadingDiamondCIplot()`

.

```
diamondCoordinates(
values,
otherAxisValue = 1,
direction = "horizontal",
autoSize = NULL,
fixedSize = 0.15
)
ggDiamondLayer(
data,
ciCols = 1:3,
colorCol = NULL,
generateColors = NULL,
fullColorRange = NULL,
color = "black",
lineColor = NA,
otherAxisCol = 1:nrow(data),
autoSize = NULL,
fixedSize = 0.15,
direction = "horizontal",
...
)
rawDataDiamondLayer(
dat,
items = NULL,
itemOrder = 1:length(items),
dataAlpha = 0.1,
dataColor = "#444444",
jitterWidth = 0.5,
jitterHeight = 0.4,
size = 3,
...
)
varsToDiamondPlotDf(
dat,
items = NULL,
labels = NULL,
decreasing = NULL,
conf.level = 0.95
)
```

- values
A vector of 2 or more values that are used to construct the diamond coordinates. If three values are provided, the middle one becomes the diamond's center. If two, four, or more values are provided, the median becomes the diamond's center.

- otherAxisValue
The value on the other axis to use to compute the coordinates; this will be the Y axis value of the points of the diamond (if

`direction`

is 'horizontal') or the X axis value (if`direction`

is 'vertical').- direction
Whether the diamonds should be constructed horizontally or vertically.

- autoSize
Whether to make the height of each diamond conditional upon its length (the width of the confidence interval).

- fixedSize
If not using relative heights,

`fixedSize`

determines the height to use.- data, dat
A dataframe (or matrix) containing lower bounds, centers (e.g. means), and upper bounds of intervals (e.g. confidence intervals) for

`ggDiamondLayer`

or items and raw data for`varsToDiamondPlotDf`

and`rawDataDiamondLayer`

.- ciCols
The columns in the dataframe with the lower bounds, centers (e.g. means), and upper bounds (in that order).

- colorCol
The column in the dataframe containing the colors for each diamond, or a vector with colors (with as many elements as the dataframe has rows).

- generateColors
A vector with colors to use to generate a gradient. These colors must be valid arguments to

`colorRamp()`

(and therefore, to`col2rgb()`

).- fullColorRange
When specifying a gradient using

`generateColors`

, it is usually desirable to specify the minimum and maximum possible value corresponding to the outer anchors of that gradient. For example, when plotting numbers from 0 to 100 using a gradient from 'red' through 'orange' to 'green', none of the means may actually be 0 or 100; the lowest mean may be, for example, 50. If no`fullColorRange`

is specified, the diamond representing that lowest mean of 50 wil be red, not orange. When specifying the`fullColorRange`

, the lowest and highest 'colors' in`generateColors`

are anchored to the minimum and maximum values of`fullColorRange`

.- color
When no colors are automatically generated, all diamonds will have this color.

- lineColor
If NA, lines will have the same colors as the diamonds' fill. If not NA, must be a valid color, which is then used as line color. Note that e.g.

`linetype`

and`color`

can be used as well, which will be passed on to`geom_polygon()`

.- otherAxisCol
A vector of values, or the index of the column in the dataframe, that specifies the values for the Y axis of the diamonds. This should normally just be a vector of consecutive integers.

- ...
Any additional arguments are passed to

`geom_polygon()`

. This can be used to set, for example, the`alpha`

value of the diamonds. Additional arguments for`rawDataDiamondLayer`

are passed on to`geom_jitter()`

.- items
The items from the dataframe to include in the diamondplot or dataframe.

- itemOrder
Order of the items to use (if not sorting).

- dataAlpha
This determines the alpha (transparency) of the data points.

- dataColor
The color of the data points.

- jitterWidth
How much to jitter the individual datapoints horizontally.

- jitterHeight
How much to jitter the individual datapoints vertically.

- size
The size of the data points.

- labels
The item labels to add to the dataframe.

- decreasing
Whether to sort the items (rows) in the dataframe decreasing (TRUE), increasing (FALSE), or not at all (NULL).

- conf.level
The confidence of the confidence intervals.

`ggDiamondLayer`

returns a `ggplot()`

`geom_polygon()`

object, which can then be used in
`ggplot()`

plots (as `diamondPlot()`

does).

`diamondCoordinates`

returns a set of four coordinates that together
specify a diamond.

`varsToDiamondPlotDf`

returns a dataframe of diamondCoordinates.

`rawDataDiamondLayer`

returns a `geom_jitter()`

object.

```
if (FALSE) {
### (Don't run this example as a test, because we
### need the ggplot function which isn't part of
### this package.)
### The coordinates for a simple diamond
diamondCoordinates(values = c(1,2,3));
### Plot this diamond
ggplot() + ggDiamondLayer(data.frame(1,2,3));
}
```