📌
Getting started
📂
Data Organization
📝
Labeling
🤝
Collaboration
⚙
Data Manipulation
🔮
Neural Networks
👔
Enterprise Edition
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:
- 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:
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.
- 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
Last modified 2yr ago