The puzzle: https://adventofcode.com/2023/day/10
My Ada solution: here.
In a picture (generated by the program linked above)...
 |
| Click to enlarge |
It is always a pleasure to display the data created by Eric Wastl.
Here, an improved representation with the five cases (outside tile, inside tile, inside pixel on a path tile, outside pixel on a path tile, path pixel) in shown different colors:
 |
| Click to enlarge |
Note for subscribers: if you are interested in my Ada programming articles only, you can use this RSS feed link.
LEA, the Lightweight Editor for Ada, is based on the Scintilla text editor widget, which excels at colouring syntactic elements and letting the user rework his or her programs very swiftly, including manipulating rectangular selections and adding text on multiple points (usually vertically aligned).
But until recently, the cool features were limited to automatic indentation, adding comment delimiters (--) at the right column, or highlighting portions of text that match a selection.
Users were frustrated by not finding in LEA programming helpers (commonly grouped under the term "smart editor" or "intellisense") that they enjoy in their programming "studios".
An excuse would have been to dismiss such features as out of the scope of a "lightweight" editor.
But we know we can make of LEA a powerful mini-studio, with the ease of use of a simple editor, thanks to its "projectless" mode and the integrated HAC compiler.
So now, it happened.
From revision 385 of LEA (and revision 886 of HAC), you have now a good sense of intellisense:
Some screenshots will help illustrate the above points. Let's start with the sudoku_sample.adb example shipped with the HAC project. What's that "Sudo_Strings" type, for instance?
Just let the mouse pointer hang out around an occurrence of that keyword.
 |
| Mouse hover tip - Click image to enlarge it |
 |
| Go to declaration - Click image to enlarge it |
 |
| Declaration in the Sudoku package - Click image to enlarge it |
 |
| Call tip - Click image to enlarge it |
 |
| Auto-complete - Click image to enlarge it |
In order to develop the last point, here are a few examples on how LEA understands your program "on the fly", while you are typing it:
 |
| Smart editor on an incomplete piece of code - Click image to enlarge it |
 |
| Smart editor on an incomplete piece of code, sample 2 - Click image to enlarge it |
 |
| Smart editor on an incomplete piece of code, sample 3 - Click image to enlarge it |
Some Web links:
LEA
Web site: http://l-e-a.sf.net/
Sources, site #1: https://sf.net/p/l-e-a/code/HEAD/tree/
Sources, site #2: https://github.com/zertovitch/lea
Alire Crate: Alire - LEA
Web site: https://hacadacompiler.sourceforge.io/
Sources, site #1: https://sf.net/p/hacadacompiler/code/HEAD/tree/
Sources, site #2: https://github.com/zertovitch/hac
Alire Crate: Alire - HAC
Enjoy!
Note for subscribers: if you are interested in my Ada programming articles only, you can use this RSS feed link.
Spot the "tool tip" on the following screenshot...
 |
| Click to enlarge |
Translation: cross-references and source code navigation in LEA are becoming a reality since this evening!
Some Web links:
LEA
Web site: http://l-e-a.sf.net/
Sources, site #1: https://sf.net/p/l-e-a/code/HEAD/tree/
Sources, site #2: https://github.com/zertovitch/lea
Alire Crate: Alire - LEA
Since LEA embeds the HAC compiler, here are a few links about HAC as well:
HAC
Web site: https://hacadacompiler.sourceforge.io/
Sources, site #1: https://sf.net/p/hacadacompiler/code/HEAD/tree/
Sources, site #2: https://github.com/zertovitch/hac
Alire Crate: Alire - HAC
Main URL: https://hacadacompiler.sourceforge.io/
Sources, site #1: HAC Ada Compiler download | SourceForge.net
Sources, site #2: GitHub - zertovitch/hac: HAC Ada Compiler - a small, quick Ada compiler fully in Ada
Alire Crate: Alire - Hac
What’s new:
Login
exit statement: exit Loop_Name.exit Loop_Name.(i)(j) (array of array) and (i, j) (multi-dimensional array) are no more treated as equivalent (this feature was a remnant of the Pascal syntax).+, -, & for strings) are visible without prefix only in the scope of a use HAT clause.Note that correct Ada programs, in relation to the above points, were already accepted and parsed correctly by HAC before that change.
Finally, a bit of cosmetics in the build messages:
C:\Ada\hac\exm>..\hac -v2 -c pkg_demo.adb
*******[ HAC ]******* HAC is free and open-source. Type "hac" for license.
[ HAC ] HAC Ada Compiler version 0.26, 08-Jul-2023
[ HAC ] Compiling main: pkg_demo.adb
[ HAC ] | Compiling x_pkg_demo_s.ads (specification)
[ HAC ] \ Compiling x_pkg_demo_s1.ads (specification)
[ HAC ] \ Compiling x_pkg_demo_s11.ads (specification)
[ HAC ] / x_pkg_demo_s11.ads: done.
[ HAC ] \ Compiling x_pkg_demo_s12.ads (specification)
[ HAC ] / x_pkg_demo_s12.ads: done.
[ HAC ] \ Compiling x_pkg_demo_s13.ads (specification)
[ HAC ] / x_pkg_demo_s13.ads: done.
[ HAC ] / x_pkg_demo_s1.ads: done.
[ HAC ] \ Compiling x_pkg_demo_s2.ads (specification)
[ HAC ] \ Compiling x_pkg_demo_s21.ads (specification)
[ HAC ] / x_pkg_demo_s21.ads: done.
[ HAC ] \ Compiling x_pkg_demo_s22.ads (specification)
[ HAC ] / x_pkg_demo_s22.ads: done.
[ HAC ] \ Compiling x_pkg_demo_s23.ads (specification)
[ HAC ] / x_pkg_demo_s23.ads: done.
[ HAC ] / x_pkg_demo_s2.ads: done.
[ HAC ] \ Compiling x_pkg_demo_s3.ads (specification)
[ HAC ] \ Compiling x_pkg_demo_s31.ads (specification)
[ HAC ] / x_pkg_demo_s31.ads: done.
[ HAC ] \ Compiling x_pkg_demo_s32.ads (specification)
[ HAC ] / x_pkg_demo_s32.ads: done.
[ HAC ] \ Compiling x_pkg_demo_s33.ads (specification)
[ HAC ] / x_pkg_demo_s33.ads: done.
[ HAC ] / x_pkg_demo_s3.ads: done.
[ HAC ] | x_pkg_demo_s.ads: done.
[ HAC ] | Compiling x_pkg_demo_m.ads (specification)
[ HAC ] | x_pkg_demo_m.ads: done.
[ HAC ] | Compiling x_pkg_demo_b.ads (specification)
[ HAC ] | x_pkg_demo_b.ads: done.
[ HAC ] Compilation of pkg_demo.adb (main) completed
[ HAC ] ------ Compilation of eventual with'ed unit's bodies
[ HAC ] | Compiling x_pkg_demo_s.adb (body)
[ HAC ] | x_pkg_demo_s.adb: done.
[ HAC ] | Compiling x_pkg_demo_s1.adb (body)
Today, a topic that is guaranteed frivolous: a new colour theme for LEA (a Lightweight Editor for Ada).
Actually, it is a serious subject if you spend a large share of your time at programming (for work, for fun, or both...). For the theoretically brighter season (spring and summer), some prefer to give up the trendy Dark Side mode (which not so long ago was considered as horribly old-fashioned):
...and use a dark-font-bright-background scheme.
However, the contrast is a bit violent. A convincing and carefully designed low-contrast theme is called Solarized Light (which can be turned, with an astute swap within the same 8-colours palette for base colours, into a dark-backgrounded Solarized Dark). The theme is described here.
The Solarized Light theme is incorporated since today in LEA.
Enjoy!
LEA, a Lightweight Editor for Ada, aims to provide an easy,
script-world-like, "look & feel" for developing Ada projects of any
size and level, while enabling access to full-scale development tools
like GNAT.
Note for subscribers: if you are interested in my Ada programming articles only, you can use this RSS feed link.
Just as a teaser for the next Advent of Code in 10 1/2 months, we would like to show a few pictures related to last edition. The 25 puzzles, data and solutions can be found here and here. They are programmed with HAC (the HAC Ada Compiler), thus in a small subset of the Ada language. The HAC compiler is very fast, so you run your program without noticing it was ever compiled, which is perfect for completing a programming puzzle.
 |
| Day 22 run with HAC (here, embedded in the LEA environment) |
However, the program will run substantially slower than compiled with a native, optimizing compiler like GNAT.
This is not an issue for most Advent of Code puzzles, but for some, it is, especially on the later days. Fortunately, changing from HAC to GNAT is trivial (just switch compilers), unlike the traditional reprogramming of Python prototypes in C++, for instance.
Day 8's data is a map representing the height of trees. Once the puzzle was solved, I was curious how the forest looked like. Note that different users get different data, so you are unlikely to find a visualisation of exactly your data on the internet.
Day 12's puzzle is a shortest path problem with specific rules and a nice data - a terrain with a hill - which seems designed to trap depth-first-search algorithms into an almost infinite search. The yellowish path is the shortest from the green dot, elevation 'a', to blue dot, elevation 'z'.
The pinkish path is the shortest from the blue dot to any dot with elevation 'a'. Fortunately Dijkstra's algorithm (and perhaps others) allows for such a special criterion regarding the end point.
 |
| Click to enlarge |
For day 22’s puzzle, a walk on a cube’s surface is involved, so it is helpful to sketch it on a piece of paper, cut it and glue the faces. A banana skin of that puzzle is that the example’s layout may be different from the data’s layout. We slipped on that one and ended up gluing and programming the face-to-face transitions for two layouts…
 |
| Click to enlarge |
Other Adaists’ solutions, discussions and pictures can be found here and in the "2022 Day x" threads in the same forum.
The 0.85 version of LEA (the Lightweight Editor for Ada) is available!
Web site: http://l-e-a.sf.net/
Source repository #1: https://sf.net/p/l-e-a/code/HEAD/tree/
Source repository #2: https://github.com/zertovitch/lea
The new version has two main new features:
- Tabs (screenshot below)
- LEA doesn't write scilexer.dll as a file; thus, it runs as a portable application (in the sense: you can run it from a read-only drive directly, without installation)
 |
| Click to enlarge |
Enjoy!
Note for subscribers: if you are interested in my Ada programming articles only, you can use this RSS feed link.
Last post was about an improvement of the GWindows.Common_Controls.Ex_List_View widget which is distributed with the GWindows framework. Without changing the specification, it was possible to avoid Windows API calls during the performance-sensitive comparison function, leading to impressive speedup factors: from 3.3x with 4096 items to 16.5x with 32768 items.
But actually, it was only the prelude!
If you can live with data duplication, which is not nice and not always practical, it is possible to do much better. Concretely, you store the same strings in the cells of the List_View widget and in the payload data associated with each row. Then, the sorting for all columns (text, dates, numbers, ...) is using the payload data. An addition to the Ex_List_View package later (this time, enriching a bit the specification), the comparison function may exclusively use the payload of both compared rows, directly, thus avoiding any API call during the lifespan of the comparison function.
Without going into too many details, here are the performance gains in charts:
This represents a factor of ~100x to ~300x on top of the previous improvement, depending on the test machine.
Here are links to the sources:
AZip:
Project site & Subversion repository:
https://sf.net/projects/azip/
GitHub clone with Git repository:
https://github.com/zertovitch/azip
GWindows:
Project site & Subversion repository:
https://sf.net/projects/gnavi/
GitHub clone with Git repository:
https://github.com/zertovitch/gwindows
Note for subscribers: if you are interested in my Ada programming articles only, you can use this RSS feed link.
The 0.84 version of LEA (the Lightweight Editor for Ada) is available!
Web site: http://l-e-a.sf.net/
Source repository #1: https://sf.net/p/l-e-a/code/HEAD/tree/
Source repository #2: https://github.com/zertovitch/lea
This version is essentialy a rework of LEA's ergonomy - we had recently the chance of having a group of young first-time programmers and first-time LEA users to test it!
The main addition is the green Build & Run button, which matches a (less intuitive) menu entry and the F9 key.
 |
| Click screenshot to enlarge |
Another addition is a dedicated box for the "User_Abort" internal Virtual Machine exception, so that the LEA user doesn't take the exception message for an actual error (which would be the case for any other exception).
Before:
Now:
Here is an example to illustrate how the HAC compiler is embedded in an Ada application.
The user of the application has typically only an executable (built with a "full Ada" system like GNAT) and an "Ada-pplet" (can be a few lines) that is run from that executable.
Normally, applications have different languages for building the application and for the embedded script system: Excel is written in C/C++ but embeds VBA (Visual Basic for Applications). 3D Studio Max has MaxScript. GIMP uses Script-fu, a variant of Scheme. Others use Lua or Python. Of course nobody would think about shipping a software with a scripting language where you have to fight with pointers and conditional compilation (C/C++).
But... how about an application that is written in a compiled language, but is using the same language for its scripting purposes? Since a few days, it is possible with HAC (the HAC Ada Compiler).
If you build the demo exchange_hac_side.adb (e.g. from GNAT Studio, or via the command "gprbuild hac"), you get an executable, exchange_hac_side on Linux or exchange_hac_side.exe on Windows. If you run it, you get:
Messages as "Native" are from the main application.
Messages as "HAC" are from the small HAC program that is run from the application.
A little disadvantage of having the same language on both sides... is that it is the same language! It could be confusing at first glance. Plus, it is not in the tradition. That may be disturbing for a number of people.
A big advantage of having the same language is that you can share some pieces of code. For instance the following package is used for building the demo application, and compiled by HAC when the application is running!
HAC (HAC Ada Compiler) is a quick, small, open-source Ada
compiler, covering a subset of the Ada language.
HAC is itself fully programmed in Ada.
Web site: http://hacadacompiler.sf.net/
Source repositories:
#1 svn: https://sf.net/p/hacadacompiler/code/HEAD/tree/trunk/
HAC (HAC Ada Compiler) is a quick, small, open-source Ada
compiler, covering a subset of the Ada language.
HAC is itself fully programmed in Ada.
Web site: http://hacadacompiler.sf.net/
From there, links to sources, and an executable for Windows.
Source repositories:
#1 svn: https://sf.net/p/hacadacompiler/code/HEAD/tree/trunk/
#2 git: https://github.com/zertovitch/hac
* Main improvements since v.0.1:
- a program run by HAC can exchange data with the
programm running HAC, through dynamically registered call-backs
- see package HAC_Sys.Interfacing and demos:
src/apps/exchange_native_side.adb
src/apps/exchange_hac_side.adb
- the compiler checks that all choices in a CASE statement
are covered
- the compiler performs more compile-time range checks and
optimizes away useless run-time checks when it's safe to do so.
Enjoy!
Gautier
HAC (HAC Ada Compiler) is a quick, small, open-source Ada
compiler, covering a subset of the Ada language.
HAC is itself fully programmed in Ada.
Web site: http://hacadacompiler.sf.net/
From there, links to sources and an executable for Windows.
Source repositories:
#1 svn: https://sf.net/p/hacadacompiler/code/HEAD/tree/trunk/
#2 git: https://github.com/zertovitch/hac
* Main improvements since v.0.0996:
- packages and subpackages are now supported
- modularity: packages and subprograms can be standalone
library units, stored in individual files with
GNAT's naming convention, and accessed from other units
via the WITH clause
- validity checks were added for a better detection of
uninitialized variables.
Package examples and modularity tests have been added.
Particularly, a new PDF producer package with a few demos
is located in the ./exm/pdf directory.
Enjoy!
Gautier
__
PS: for Windows, there is an integrated editor that embeds HAC:
LEA: http://l-e-a.sf.net
PPS: HAC will be shown at the Ada-Europe conference (presentation + tutorial)
http://www.ada-europe.org/conference2022/
In order to illustrate a feature, what is better than a visual example?
In our case, the feature is the modularity, recently implemented in HAC (the HAC Ada Compiler).
So, a nice exercise was to try with a "real" visual package, PDF_Out (project Ada PDF Writer, link here).
Of course, HAC is still a small compiler project which doesn't cover all the sexy features of Ada - even those of the first version of Ada, Ada 1983, which already had extensive generics, aggregates (on-the-fly composite objects as expressions), default values in records or in subprogram parameters, exceptions or user-defined operators.
The easy way of down-stripping PDF_Out for HAC was to open the source code in the LEA editor (link here), and do frenetically and iteratively:
loop
punch the compile key (F4)
exit when the package compiles!
make the code HAC-compatible (sometimes, it hurts!)
end loop
A few things that needed a downgrade for the HAC 0.1 language subset were:
The result can be seen here:
 |
| Click to enlarge |
You can experiment it yourself by checking out or cloning the latest version of HAC:
#1 svn: https://sf.net/p/hacadacompiler/code/HEAD/tree/trunk/
#2 git: https://github.com/zertovitch/hac
The new PDF examples are located in the subdirectory ./exm/pdf
Drum rolls: HAC (the HAC Ada Compiler) now supports packages.
OK, there is still a slight limitation: library-level packages cannot contain variables and constants, nor an initialization part (begin .. end). Removing this limitation would be complex to implement and is postponed so far for HAC.
A new modularity demo can be found in the "exm" subdirectory.
The main file is "pkg_demo.adb".
It is a simple test for simulating the build of an application with numerous dependencies.
The dependencies take form of packages depending on two or more other packages, down to
a certain recursion depth.
Each package contains a procedure with the same name: "Do_it", which just writes a string related to the package name. For instance, X_Pkg_Demo_B3.Do_it will write "[B3]", then call X_Pkg_Demo_B31.Do_it, X_Pkg_Demo_B32.Do_it, and X_Pkg_Demo_B33.Do_it.
The package dependencies can be seen the following chart:
NB: the depth and number of children can be set as you wish.
How to run the demo?
First, we generate the package tree.
For that, assume you have the "hac[.exe]" executable ready in the main directory.
Note: in what follows, replace '/' by '\' if you are on Windows.
In the "exm" directory, run from the command line: "../hac pkg_demo_gen.adb".
Alternatively, from LEA, load "pkg_demo_gen.adb" and run it (F9).
The packages ("x_*" files) will be generated.
Now, from the command line, run "../hac pkg_demo.adb" (or from LEA, load it and punch F9).
The result is:
Specs: [S][S1][S11][S12][S13][S2][S21][S22][S23][S3][S31][S32][S33]
Mixed: [M][M1][M11][M12][M13][M2][M21][M22][M23][M3][M31][M32][M33]
Bodies: [B][B1][B11][B12][B13][B2][B21][B22][B23][B3][B31][B32][B33]
If you are curious about how HAC does the whole build the 40 units (main procedure and 39 packages),
add the "-v2" option to the build command: "../hac -v2 pkg_demo.adb".
On an i7 machine (with HAC itself built in "Fast" mode), the time elapsed
for the entire build is around 0.08 seconds. Only one core is used.
Since GNAT builds also the library "on the fly" by automatically
finding dependencies, you can see it in action by doing:
"gnatmake -I../src -j0 pkg_demo"
Interestingly, GNAT compiles the packages for each depth successively.
Then you can see the result by doing:
"./pkg_demo"
Of course, it's identical to HAC's.
---
HAC (the HAC Ada Compiler) is a small, quick, open-source Ada compiler,
covering a subset of the Ada language.
HAC is itself fully programmed in Ada.
Web site: http://hacadacompiler.sf.net/
Source repositories:
#1 svn: https://sf.net/p/hacadacompiler/code/HEAD/tree/trunk/
#2 git: https://github.com/zertovitch/hac
Enjoy!
Gautier
Since a few commits, HAC parses packages! But so far there are limitations : it's "work in progress".
Nevertheless you can already play a bit with the things already programmed in HAC.
File prc.ads:
with Pkg_1, Pkg_2;
procedure Prc is
x : Pkg_1.A;
use Pkg_1, Pkg_2;
xg : G;
y : B;
z : Pkg_1.E;
begin
x := 0;
y := 0;
z := 2;
end;
File pkg_1.ads:
File pkg_2.ads:
with Pkg_1;
package Pkg_2 is
subtype F is Pkg_1.E;
use Pkg_1.Sub_Pkg;
subtype G is D;
end Pkg_2;
Now, from the command-line (assume you are in the main hac directory), do:
hac -v2 prc.adb
*******[ HAC ]******* Compiler version: 0.0997 dated 19-Mar-2022.
*******[ HAC ]******* Caution: HAC is not a complete Ada compiler. Type "hac" for license.
. . . .[ HAC ]. . . . Compiling main: prc.adb
. . . .[ HAC ]. . . . .Compiling: pkg_1.ads (specification)
. . . .[ HAC ]. . . . .Compilation of pkg_1.ads completed
. . . .[ HAC ]. . . . .Compiling: pkg_2.ads (specification)
. . . .[ HAC ]. . . . .Compilation of pkg_2.ads completed
. . . .[ HAC ]. . . . Compilation of prc.adb (main) completed
. . . .[ HAC ]. . . . -- Compilation of eventual with'ed unit's bodies --
. . . .[ HAC ]. . . . Build finished in 0.001255600 seconds.
. . . .[ HAC ]. . . . Object code size: 12 of 100000 Virtual Machine instructions.
. . . .[ HAC ]. . . . Starting p-code VM interpreter...
-------[ HAC ]------- VM interpreter done after 0.045569300 seconds.
Execution of prc.adb completed.
Maximum stack usage: 10 of 4000000 units, around 0%.
If you want a more complex example of how HAC can create the library "on the fly" by compiling recursively everything needed to build the main procedure, it is already in the examples (subdirectory exm):
*******[ HAC ]******* Compiler version: 0.0997 dated 19-Mar-2022.
*******[ HAC ]******* Caution: HAC is not a complete Ada compiler. Type "hac" for license.
. . . .[ HAC ]. . . . Compiling main: unit_a.adb
. . . .[ HAC ]. . . . .Compiling: unit_b.ads (specification)
. . . .[ HAC ]. . . . .Compilation of unit_b.ads completed
. . . .[ HAC ]. . . . .Compiling: unit_c.adb (body)
. . . .[ HAC ]. . . . .Compilation of unit_c.adb completed
. . . .[ HAC ]. . . . Compilation of unit_a.adb (main) completed
. . . .[ HAC ]. . . . -- Compilation of eventual with'ed unit's bodies --
. . . .[ HAC ]. . . . .Compiling: unit_b.adb (body)
. . . .[ HAC ]. . . . ..Compiling: unit_e.adb (body)
. . . .[ HAC ]. . . . ..Compilation of unit_e.adb completed
. . . .[ HAC ]. . . . ..Compiling: unit_f.ads (specification)
. . . .[ HAC ]. . . . ...Compiling: unit_g.ads (specification)
. . . .[ HAC ]. . . . ...Compilation of unit_g.ads completed
. . . .[ HAC ]. . . . ..Compilation of unit_f.ads completed
. . . .[ HAC ]. . . . .Compilation of unit_b.adb completed
. . . .[ HAC ]. . . . -- Compiled bodies: 1
. . . .[ HAC ]. . . . .Compiling: unit_f.adb (body)
. . . .[ HAC ]. . . . .Compilation of unit_f.adb completed
. . . .[ HAC ]. . . . .Compiling: unit_g.adb (body)
. . . .[ HAC ]. . . . .Compilation of unit_g.adb completed
. . . .[ HAC ]. . . . -- Compiled bodies: 2
. . . .[ HAC ]. . . . Build finished in 0.006483700 seconds.
. . . .[ HAC ]. . . . Object code size: 350 of 100000 Virtual Machine instructions.
. . . .[ HAC ]. . . . Starting p-code VM interpreter...
Unit_A: demo of modularity features for subprograms.
------
HAC (HAC Ada Compiler) is a small, quick, open-source Ada compiler,
covering a subset of the Ada language.
HAC is itself fully programmed in Ada.
Web site: http://hacadacompiler.sf.net/
Source repositories:
#1 svn: https://sf.net/p/hacadacompiler/code/HEAD/tree/trunk/
#2 git: https://github.com/zertovitch/hac
Enjoy!
QOI (the Quite OK Image Format, home page here) is a very simple raster image format with a decent lossless compression and an extremely good performance - a direct consequence of its simplicity and its compression features.
It was clear from the first sight on that format that it was urgent to add it to GID, the Generic Image Decoder 😎. GID is free, open-source, available on SourceForge here and GitHub here.
Here, a few examples of QOI test images decoded by GID (with its default background for transparency):
The cool ideas in the QOI format are
Transparency, in the form of levels from 0 to 255, (the alpha channel) is supported.
Add to it a run-length encoding that fits well surfaces with identical colours and transparency, and the format remains so simple that you can squeeze its detailed specification on a single, readable, A4 page!
|
| Click to enlarge |
We've caught the "all RGB" virus!
The allRGB site shows many pictures with a very special characteristic: each colour (of the standard 8-bit-per-channel rendering) appears in one and only one pixel.
With 8-bit-per-channel rendering, you have 2^8 = 256 values of red, 256 values of green, 256 values of blue.
As a result, you have 256 * 256 * 256 = 16,777,216 different colors.
Of course, we could not resist making our own "all RGB" demo around GID (the Generic Image Decoder).
You can find now in the test directory in the GID project (available on SourceForge here and GitHub here), a new all_rbg.adb program that transforms an image into a similar image in which each pixel has a different colour and all 8-bit-per-channel colours are displayed.
Actually, our algorithm goes differently: it starts with a trivial, deterministic "all RGB" image...
...makes it uniform by swapping pixels randomly...
...then modifies it progressively in order to make it look like the image you have given.
This is done, at each step, by choosing two pixels randomly, and swapping them, or not, depending on how the pair resembles the given image.
The invariant of the algorithm is that the image, during the whole process, stays "all RGB".
Here is an example (all images are reduced for this blog post). Original photography (pictured: a village called Ottrott in Alsace):
Here, a detail:
HAC (HAC Ada Compiler) is a small, quick, open-source Ada compiler,
covering a subset of the Ada language.
HAC is itself fully programmed in Ada.
Web site: http://hacadacompiler.sf.net/
Source repositories:
#1 svn: https://sf.net/p/hacadacompiler/code/HEAD/tree/trunk/
#2 git: https://github.com/zertovitch/hac
Main improvements since v.0.095:
Enjoy!
Gautier
PS: for Windows there is an integrated editor that embeds HAC:
LEA: http://l-e-a.sf.net
