Vectorize bitmap

Preface
Suppose we have some annotations of shape "bitmap", but want to work with vector objects. What can we do? Use DTL, of course.
The task is very common. Annotations in form of masks may be obtained from different sources, including:
manual annotation, may be with our awesome Smart Tool​
segmentation results from some appropriate neural network, e.g. UNet​
something else
But in many cases it is preferable to work with or produce result in form of vector objects. They are, after all, sligtly more... machine-friendly.
Let's start with some image. Annotate it with Smart Tool and get a single mask of class "char-bitmap".
Source image.
Source image with mask object.
Find contours
The most natural action is to find contours of mask. We can simply do it with Find Contours layer. From our single mask (shape "bitmap") it will generate some polygons -- with holes, if it's needed.
After that, we can find that resulting polygons have too many vertices. If we aren't satisfied with it, decrease number of vertices by approximating the polygons. Approx Vector layer will help us.
Here is the DTL graph:
1
[
2
  {
3
    "action": "data",
4
    "src": [
5
      "wai/ds"
6
    ],
7
    "dst": "$sample0",
8
    "settings": {
9
      "classes_mapping": "default"
10
    }
11
  },
12
  {
13
    "dst": "$sample2",
14
    "src": [
15
      "$sample0"
16
    ],
17
    "action": "find_contours",
18
    "settings": {
19
      "classes_mapping": {
20
        "char-bitmap": "char-poly"
21
      }
22
    }
23
  },
24
  {
25
    "action": "approx_vector",
26
    "src": [
27
      "$sample2"
28
    ],
29
    "dst": "$sample3",
30
    "settings": {
31
      "classes": [
32
        "char-poly"
33
      ],
34
      "epsilon": 2
35
    }
36
  },
37
  {
38
    "action": "supervisely",
39
    "src": [
40
      "$sample3"
41
    ],
42
    "dst": "wai-contours",
43
    "settings": {}
44
  }
45
]
Copied!
Here is the result:
Source mask.
Polygons after processing.
Now we got six polygons, with required holes in the largest.
Largest polygon selected
Let's see how approximation works:
Polygon after "Find Polygons" without approximation.
Polygon after approximation (epsilon=2).
Get skeleton
Another thing which may be required is extracting a skeleton from a bitmap. Simple DTL pipeline allows to do it. We will get figures of shape "line" as a result.
Here is the example of converting our "line-shaped" bitmap to convenient vector objects. We'll do the following:
Thin bitmap with Skeletonize layer, getting bitmap of "one-pixel edges".
Convert thinned bitmap to objects of shape "line" with Bitmap to Lines layer.
approximate line objects to decrease number of vertices with Approx Vector layer.
Here is the DTL graph:
1
[
2
  {
3
    "action": "data",
4
    "src": [
5
      "wai/ds"
6
    ],
7
    "dst": "$sample0",
8
    "settings": {
9
      "classes_mapping": "default"
10
    }
11
  },
12
  {
13
    "dst": "$sample1",
14
    "src": [
15
      "$sample0"
16
    ],
17
    "action": "skeletonize",
18
    "settings": {
19
      "method": "thinning",
20
      "classes": [
21
        "char-bitmap"
22
      ]
23
    }
24
  },
25
  {
26
    "dst": "$sample2",
27
    "src": [
28
      "$sample1"
29
    ],
30
    "action": "bitmap2lines",
31
    "settings": {
32
      "min_points_cnt": 2,
33
      "classes_mapping": {
34
        "char-bitmap": "char-line"
35
      }
36
    }
37
  },
38
  {
39
    "action": "approx_vector",
40
    "src": [
41
      "$sample2"
42
    ],
43
    "dst": "$sample3",
44
    "settings": {
45
      "classes": [
46
        "char-line"
47
      ],
48
      "epsilon": 2
49
    }
50
  },
51
  {
52
    "action": "supervisely",
53
    "src": [
54
      "$sample3"
55
    ],
56
    "dst": "wai-vectorized",
57
    "settings": {}
58
  }
59
]
Copied!
Here is the result:
Source mask.
Resulting skeleton, figures of shape "line".
In details, this is how Skeletonize layer works:
Source mask.
Thinned mask. It's still a figure of shape "bitmap".
And this is why we need approximation with Approx Vector layer:
Line obtained brom bitmap, without approximation.
The line after approximation: two vertices.
Of course, the approximation may be "softer", producing smoother lines with more vertices. It is tuned by epsilon parameter in Approx Vector layer.
Duplicate Objects for complicated conversions
As an example, consider the two pipelines above. Our purpose is to get the following figures on the same image:
source mask ("bitmap")
found contours ("polygon"s)
found skeleton ("line"s)
It is useful in different cases, which this margin is too narrow to contain.
We'll simply apply Duplicate Objects layer to copy objects. Actually, we'll apply it twice:
There is a class "char-bitmap", and we want to save it.
Clone it to temporary class "bitmap-to-poly", which will be converted to "char-poly" polygons later.
And clone "char-bitmap" again to temporary class "bitmap-to-line", which will be converted to "char-line" lines later.
After that, we just need to stack the previous two pipelines. No branching.
Here is the DTL graph:
1
[
2
  {
3
    "action": "data",
4
    "src": [
5
      "wai/ds"
6
    ],
7
    "dst": "$sample",
8
    "settings": {
9
      "classes_mapping": "default"
10
    }
11
  },
12
  {
13
    "dst": "$dupl-1",
14
    "src": [
15
      "$sample"
16
    ],
17
    "action": "duplicate_objects",
18
    "settings": {
19
      "classes_mapping": {
20
        "char-bitmap": "bitmap-to-poly"
21
      }
22
    }
23
  },
24
  {
25
    "dst": "$dupl-2",
26
    "src": [
27
      "$dupl-1"
28
    ],
29
    "action": "duplicate_objects",
30
    "settings": {
31
      "classes_mapping": {
32
        "char-bitmap": "bitmap-to-line"
33
      }
34
    }
35
  },
36
  {
37
    "dst": "$thinned",
38
    "src": [
39
      "$dupl-2"
40
    ],
41
    "action": "skeletonize",
42
    "settings": {
43
      "method": "thinning",
44
      "classes": [
45
        "bitmap-to-line"
46
      ]
47
    }
48
  },
49
  {
50
    "dst": "$lines-1",
51
    "src": [
52
      "$thinned"
53
    ],
54
    "action": "bitmap2lines",
55
    "settings": {
56
      "min_points_cnt": 2,
57
      "classes_mapping": {
58
        "bitmap-to-line": "char-line"
59
      }
60
    }
61
  },
62
  {
63
    "action": "approx_vector",
64
    "src": [
65
      "$lines-1"
66
    ],
67
    "dst": "$lines-2",
68
    "settings": {
69
      "classes": [
70
        "char-line"
71
      ],
72
      "epsilon": 2
73
    }
74
  },
75
  {
76
    "dst": "$contours-1",
77
    "src": [
78
      "$lines-2"
79
    ],
80
    "action": "find_contours",
81
    "settings": {
82
      "classes_mapping": {
83
        "bitmap-to-poly": "char-poly"
84
      }
85
    }
86
  },
87
  {
88
    "action": "approx_vector",
89
    "src": [
90
      "$contours-1"
91
    ],
92
    "dst": "$contours-2",
93
    "settings": {
94
      "classes": [
95
        "char-poly"
96
      ],
97
      "epsilon": 2
98
    }
99
  },
100
  {
101
    "action": "supervisely",
102
    "src": [
103
      "$contours-2"
104
    ],
105
    "dst": "wai-three-classes",
106
    "settings": {}
107
  }
108
]
Copied!
Here is the result. Lines are purple, bitmap is blue. Polygons are yellow.
Bitmap, polygons and lines

Download filtered data

Next - Neural Networks

Basics

Last modified 1yr ago

Copy link

Contents

Preface

Find contours

Get skeleton

Duplicate Objects for complicated conversions