1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
use Cairo;
use Fornax::Hex2RGB;
subset File of Str where *.IO.f;
subset Directory of Str where *.IO.d;
#| Parses fornax format file to extract metadata.
grammar Metadata {
rule TOP { <rows> <cols> }
token rows { 'rows:' <(\d+)> }
token cols { 'cols:' <(\d+)> }
}
proto MAIN(|) is export { unless so @*ARGS { put $*USAGE; exit }; {*} }
#| Collection of tools to visualize Path Finding Algorithms
multi sub MAIN(
File $input, #= fornax format file (solved)
Directory :$output = '/tmp/output', #= output directory (existing)
Int :$frame-rate = 1, #= frame rate
Bool :$verbose = True, #= verbosity
) is export {
my Str @lines = $input.IO.lines;
my Int() %meta{Str} = Metadata.parse(@lines.first).Hash
or die "Cannot parse metadata";
# Cells as defined by fornax format.
constant $PATH = '.';
constant $BLOK = '#';
constant $DEST = '$';
constant $VIS = '-';
constant $CUR = '@';
constant %CANVAS = :1920width, :1080height;
# Colors.
constant %C = (
black => "#000000",
white => "#ffffff",
green => "#aecf90",
cyan => "#c0efff",
red => "#f2b0a2",
pointer => "#093060"
).map: {.key => hex2rgb(.value)};
# Every cell must be square. Get the maximum width, height and use
# that to decide which is to be used.
my Int %cell = width => %CANVAS<width> div %meta<cols>,
height => %CANVAS<height> div %meta<rows>;
my Int $side;
my Int %excess = :0width, :0height;
# Consider width if cells with dimension (width * width) fit
# within the canvas, otherwise consider the height.
if (%cell<width> * %meta<rows>) < %CANVAS<height> {
%excess<height> = abs %CANVAS<width> - %CANVAS<height>;
$side = %cell<width>;
} else {
%excess<width> = abs %CANVAS<width> - %CANVAS<height>;
$side = %cell<height>;
}
enum IterStatus <Walking Blocked Completed>;
for @lines.skip.kv -> $idx, $iter is rw {
my IterStatus $status;
given $iter.substr(0, 1) {
when '|' { $status = Completed }
when '!' { $status = Blocked }
default { $status = Walking }
};
# Remove marker.
$iter .= substr(1) if $status == Completed|Blocked;
put "[fornax] $idx $iter $status" if $verbose;
my @grid = $iter.comb.rotor: %meta<cols>;
warn "Invalid grid: $idx $iter $status" unless @grid.elems == %meta<rows>;
given Cairo::Image.create(
Cairo::FORMAT_ARGB32, %CANVAS<width>, %CANVAS<height>
) {
given Cairo::Context.new($_) {
# Paint the entire canvas white.
.rgb: |%C<white>;
.rectangle(0, 0, %CANVAS<width>, %CANVAS<height>);
.fill;
.stroke;
for ^%meta<rows> -> $r {
for ^%meta<cols> -> $c {
my Int @target = %excess<width> div 2 + $c * $side,
%excess<height> div 2 + $r * $side,
$side, $side;
.rectangle: |@target;
given @grid[$r][$c] -> $cell {
when $cell eq $VIS|$CUR {
.rgba: |%C<cyan>, 0.64;
.rgba: |%C<green>, 0.96 if $status == Completed;
.rgba: |%C<red>, 0.96 if $status == Blocked;
}
when $cell eq $BLOK { .rgba: |%C<black>, 0.48 }
when $cell eq $DEST { .rgb: |%C<green> }
default { .rgba: |%C<black>, 0.08 }
}
.fill :preserve;
.rgb: |%C<black>;
.rectangle: |@target;
.stroke;
}
}
}
.write_png("%s/%08d.png".sprintf: $output, $idx);
.finish;
}
}
put "[fornax] Generated images." if $verbose;
put "[fornax] Creating a slideshow." if $verbose;
run «ffmpeg -loglevel error -r "$frame-rate" -i "$output/\%08d.png"
-vcodec libx264 -crf 28 -pix_fmt yuv420p "$output/solution.mp4"»;
put "[fornax] Output: '$output'";
}
multi sub MAIN(
Bool :$version #= print version
) { say "Fornax v" ~ $?DISTRIBUTION.meta<version>; }
|