Chart.Core

In making a chart, there are three main size domains you have to be concerned about:

• the range of the data being charted. This range is often projected onto chart elements such as axes and labels. A data range in two dimensions is a Rect a.
• the scale of various chart primitives and elements. The overall dimensions of the chart canvas - the rectangular shape on which the data is represented - is referred to as an Aspect in the api, and is a wrapped Rect to distinguish aspects from rect ranges. The default chart options tend to be callibrated to Aspects around widths of one.
• the size of the chart rendered as an image. Backends tend to shrink charts to fit the rectangle shape specified in the render function, and a loose sympathy is expected between the aspect and a chart's ultimate physical size.

Jumping ahead a bit, the code snippet below draws vertical lines using a data range of "Rect 0 12 0 0.2" (slightly different to the actual data range), using a widescreen (3:1) aspect, and renders the chart as a 300 by 120 pixel svg:

scaleExample :: IO ()
scaleExample =
    fileSvg "other/scaleExample.svg" (#size .~ Pair 300 120 $ def) $
    withHud
      def
      widescreen
      (Rect 0 12 0 0.2)
      (lineChart (repeat def))
      (vlineOneD ((0.01*) <$> [0..10]))

Chart types

type Chart b = (Renderable (Path V2 Double) b, Renderable (Text Double) b) => QDiagram b V2 Double Any

A Chart is simply a type synonym for a typical Diagrams object. A close relation to this type is Diagram B, but this usage tends to force a single backend (B comes from the backend libraries), so making Chart b's maintains backend polymorphism.

Just about everything - text, circles, lines, triangles, charts, axes, titles, legends etc - are Charts, which means that most things are amenable to full use of the combinatorially-inclined diagrams-lib.

Scaling

range :: (Foldable f, Foldable g) => g (f (Pair Double)) -> Rect Double

determine the range of a double-containered set of data

projectss :: (Functor f, Functor g) => Rect Double -> Rect Double -> g (f (Pair Double)) -> g (f (Pair Double))

project a double-containered set of data to a new Rect range

aspect :: (BoundedField a, Ord a, Multiplicative a, FromInteger a) => a -> Rect a

the aspect of a chart expressed as a ratio of x-plane : y-plane.

asquare :: Rect Double

a 1:1 aspect

sixbyfour :: Rect Double

a 1.5:1 aspect

golden :: Rect Double

golden ratio

widescreen :: Rect Double

a 3:1 aspect

skinny :: Rect Double

a skinny 5:1 aspect

data AlignH

horizontal alignment

Constructors

AlignLeft

AlignCenter

AlignRight

Instances

Eq AlignH

Methods

(==) :: AlignH -> AlignH -> Bool

(/=) :: AlignH -> AlignH -> Bool

Show AlignH

Methods

showsPrec :: Int -> AlignH -> ShowS

show :: AlignH -> String

showList :: [AlignH] -> ShowS

data AlignV

vertical alignment

Constructors

AlignTop

AlignMid

AlignBottom

Instances

Eq AlignV

Methods

(==) :: AlignV -> AlignV -> Bool

(/=) :: AlignV -> AlignV -> Bool

Show AlignV

Methods

showsPrec :: Int -> AlignV -> ShowS

show :: AlignV -> String

showList :: [AlignV] -> ShowS

alignHU :: AlignH -> Double

conversion of horizontal alignment to (one :: Range Double) limits

alignHTU :: AlignH -> Double

svg text is forced to be lower left (-0.5) by default

alignVU :: AlignV -> Double

conversion of vertical alignment to (one :: Range Double) limits

alignVTU :: AlignV -> Double

svg text is lower by default

Types

data Orientation

Orientation for an element. Watch this space for curvature!

Constructors

Hori

Vert

Instances

Eq Orientation

Methods

(==) :: Orientation -> Orientation -> Bool

(/=) :: Orientation -> Orientation -> Bool

Show Orientation

Methods

showsPrec :: Int -> Orientation -> ShowS

show :: Orientation -> String

showList :: [Orientation] -> ShowS

data Place

Placement of elements around (what is implicity but maybe shouldn't just be) a rectangular canvas

Constructors

PlaceLeft

PlaceRight

PlaceTop

PlaceBottom

Instances

Eq Place

Methods

(==) :: Place -> Place -> Bool

(/=) :: Place -> Place -> Bool

Show Place

Methods

showsPrec :: Int -> Place -> ShowS

show :: Place -> String

showList :: [Place] -> ShowS

Combinators

The concept of a point on a chart is the polymorphic R2 from the linear library. Diagrams most often uses Point, which is a wrapped V2. The Pair type from 'numhask-range' is often used as a point reference.

positioned :: R2 r => r Double -> Chart b -> Chart b

position an element at a point

p_ :: R2 r => r Double -> Point V2 Double

convert an R2 to a diagrams Point

r_ :: R2 r => r a -> V2 a

convert an R2 to a V2

stack :: (R2 r, V a ~ V2, Foldable t, Juxtaposable a, Semigroup a, N a ~ Double, Monoid a) => r Double -> (b -> a) -> t b -> a

foldMap for beside; stacking chart elements in a direction, with a premap

vert :: (V a ~ V2, Foldable t, Juxtaposable a, Semigroup a, N a ~ Double, Monoid a) => (b -> a) -> t b -> a

combine elements vertically, with a premap

hori :: (V a ~ V2, Foldable t, Juxtaposable a, Semigroup a, N a ~ Double, Monoid a) => (b -> a) -> t b -> a

combine elements horizontally, with a premap

sepVert :: Double -> Chart b -> Chart b

vertical separator

sepHori :: Double -> Chart b -> Chart b

horizontal separator

Color

chart-unit exposes the colour and palette libraries for color combinators

ucolor :: (Floating a, Ord a) => a -> a -> a -> a -> AlphaColour a

convert an rgba spec to an AlphaColour

ublue :: AlphaColour Double

the official chart-unit blue

ugrey :: AlphaColour Double

the official chart-unit grey

Compatability

scaleX :: (N t ~ Double, Transformable t, R2 (V t), Additive (V t)) => Double -> t -> t

the diagrams scaleX with a zero divide guard to avoid error throws

scaleY :: (N t ~ Double, Transformable t, R2 (V t), Additive (V t)) => Double -> t -> t

the diagrams scaleY with a zero divide guard to avoid error throws

scale :: (N t ~ Double, Transformable t, R2 (V t), Additive (V t)) => Double -> t -> t

the diagrams scale with a zero divide guard to avoid error throws

Orphan instances

R1 Pair

These are difficult to avoid

Methods

_x :: Functor f => (a -> f a) -> Pair a -> f (Pair a)

R2 Pair

Methods

_y :: Functor f => (a -> f a) -> Pair a -> f (Pair a)

_xy :: Functor f => (V2 a -> f (V2 a)) -> Pair a -> f (Pair a)