emilerolley / vg

Declarative 2D vector graphics for OCaml

Emile Rolley

Human with a particular interest in strongly typed programming languages and the open-source, trying to have a meaningful impact 💚
Gitlab 🦊 • Mail 📨 • LinkedIn 🔗

---

Tip

I'm available to work on a new project, so don't hesitate to contact me if you're interested.

Currently, I'm doing voluntary work on:

• 🏛️ Publicodes, a declarative language for modeling complex business domains by breaking them down into simple elementary rules.
• 🥥 EkoFest, a lightweight and efficient web app for calculating the carbon footprint of events.

I previously worked on:

• ⚖️ Catala, a programming language toolchain used to derive correct-by-construction and transparent implementations from legislative texts.
• 🌍 Nos Gestes Climat, the ADEME official carbon footprint simulator.

vg's Issues

Fully support the `O area

• width
• cap
• join
• miter_angle
• dashes

Define the required internal data structures

Define what it's needed to store inside gstate and state records and how to initialize them.

Performance issue with the Sierpiński Arrowhead curve example

arrowhead_path:

• Vgr_cairo -> 0.25s
• Vgr_bitmap -> 2.8s

Optimize algorithms

For now list are used by default but this certainly not be the most performant approach.

• Improve the even-odd rule algorithm by implementing the scanline algorithm.
  • first attempt
  • needs to be fixed
  • manage imbricated paths

  With the scanline algorithm implementation, the performance is drastically better than cairo. However, the result is less precise that the previous implementation.

Line stroking bug (modulo y coords?)

let stroked_rect1 =
  let r =
    P.empty |> P.sub (v 0.25 0.25) |> P.line (v 1. 0.25) |> P.line (v 1. 1.)
  in
  I.cut
    ~area:(`O { P.o with P.width = 0.01 })
    r
    (I.const (Color.v 0.2 0.2 0.8 1.))

is rendered into:

Fix the bezier curve closing path bug

Implement the Bitmap module

Simple stroked line

Setup tests

Require #3 to be done.

In order to test the renderer, a simple program allowing to compare the results of Vgr_ba and other implemented renderers such as Vgr_cairo should be implemented.

At first, it could only generate two PNG images that I can compare manually.
Then, it could be interesting to automatize the comparison as it could be used in the learn-ocaml at the end.

Fix the bezier curve filling

• for curves
• issue with squares

Simple filled rectangles with the even-odd rule

Implement needed functions to render a simple filled rectangle.

Find out how to manage the view and the size.

• Determine if a point is in the view = need to be render.
• Determine how to scale point coordinates (done with the [state.scaling] value).
• Determine how to y-flip coordinates in order to correspond to the [Vg] coordinate representation.

Add anti-aliasing

Refactor the internal path representation

Currently, internal paths are rasterized as soon as possible in the set_path function: each points of path are stored. But, in order to manage transformations, a sub path should only be a list of end points of lines which could be rasterized with the bresenham_line function when the path needs to be strokes or filled.

How to

Before calling r_fill or r_stroke in r_cut, calculates all points by using the bresenham_line function.

TODOs

Refactor:

• the stroking function
• close
• line_to
• move_to
• curve_to
• the filling function
• perfomance issues
• last cleaning

Improve filling algorithms

Filling a simple square with the even-odd rule on an image of 955x590 took 4s. It is x2 with two intricated squares.
=> Not usable.

• Calculates the fitting box to iterate through instead of the whole bitmap.

Implement the r_cut function

Implement r_cut.

For this, following functions must be implemented:

• val stroke : r_state -> r_state (for now, fixed with 1-pixel width)
• val fill : r_state -> r_state
• val even_odd_rule
• val non_zero_rule
• val clip : r_state -> r_state (needed for the Cut image)

Add transformations

• Find how to manage the CTM
• Implement transfomartions functions.

Setup the architecture

Create the Vgr_bitmap module and implement main functions (according to the Vg.Vgr module) with failwith where is needed to compile.

Describe in pseudo-code main rendering algorithms

I need to describe briefly main algorithms in order to define the required internal data structures (see #2).

I need to describe precisely how to:

• combine segments of a path (see Build a rendered path from Vg path).
• render accoring a given area and a full combined path.

Support `earc`

Fix the scaling ratio

Update the documentation

Implement the set_path function

Implement set_path (see #1).

For this, following functions must be implemented:

• val move_to : r_state -> float -> float -> r_state
• val line_to : r_state -> float -> float -> r_state
• val close_path : r_state -> r_state
• val bezier_curve_to : r_state -> float -> float -> float -> float -> float -> float -> r_state
• val quadratic_curve_to : r_state -> float -> float -> float -> float -> r_state