Séquence impression
Les impressions consistent à déposer des encres sur du papier. Les technologies employées sont diverses, allant des impacts d'aiguilles sur un ruban encreur (imprimante matricielle), une fixation de poudre fine par chauffage (laser, sublimation), ou un jet d'encre (bubble jet). Les images sont formées à partir de points, semblables aux pixels des écrans, mais dans des résolutions beaucoup plus élevées (300ppi (points per inches) => 2400 points par ligne)

Du pixel au point
Tout pixel d'une image est défini par un ensemble de trois couleurs rouge, vert et bleu, facilement transformable en cyan, magenta, et jaune, voire directement en noir, en faisant la moyenne simple ou la moyenne pondérée des trois composantes.
Prenons le cas d'une seule nuance, pour ne pas dire couleur on va prendre le noir. Le blanc, en principe la couleur du papier sera représenté par un vide (absence de couleur) et le noir par *. On peut décider qu'à partir d'un certain seuil, l'équivalent du pixel devient un point noir (en anglais, c'est le mot threshold) mais l'image obtenue ne sera pas très précise.

Si votre tramage se rapporte à votre ramage...
Pour simuler les nuances, il faudra utiliser une trame de dispersion. (en anglais, dither)
Imaginons une matrice 2x2
0
__
__
 1
*_
__
 2
*_
_*
 3
**
_*
 4
**
**
L'algorithme de remplissage employé est en commençant par le point en haut à gauche, diagonale droite et basse, haut, diagonale gauche et basse (on peut en utiliser d'autres...) On pourra simuler 5 nuances, du vide au plein, c'est mieux que le seuil, mais c'est insuffisant.

Imaginons maintenant une matrice 4x4
0
____
____
____
____
 1
*___
____
____
____
 2
*___
____
__*_
____
 3
*_*_
____
__*_
____
 4
*_*_
____
*_*_
____
 5
*_*_
_*__
*_*_
____
 6
*_*_
_*__
*_*_
___*
 7
*_*_
_*_*
*_*_
___*
 8
*_*_
_*_*
*_*_
_*_*
 9
***_
_*_*
*_*_
_*_*
 10
***_
_*_*
*_**
_*_*
 11
****
_*_*
*_**
_*_*
 12
****
_*_*
****
_*_*
 13
****
**_*
****
_*_*
 14
****
**_*
****
_***
 15
****
****
****
_***
 16
****
****
****
****
On pourra simuler 16 nuances, exactement ce que l'Amiga est capable de fournir dans sa version de base. D'où la matrice de seuils suivante:
0 8 210
12 414 6
311 1 9
15713 5
Ces valeurs sont obtenues en numérotant de 0 à 15 en répartissant régulièrement les points. Donc si on veut imprimer la valeur 15, en comparant avec les points de la matrice précédente, on met tous les points en noir (ou dans une couleur choisie)
pour 10 on aura:
****
* *
* **
* *
pour 5 on aura:
* *
*
* *
*
et ainsi de suite.
Le printer.device utilise la table suivante (avec un petit bug vous devinez où, certainement là pour faire parler les bavards) 

/* 4x4 internal matrix */
prtinfo->pi_dmatrix[ 0] =  0 ;
prtinfo->pi_dmatrix[ 1] =  8 ;
prtinfo->pi_dmatrix[ 2] =  2 ;
prtinfo->pi_dmatrix[ 3] = 10 ;
prtinfo->pi_dmatrix[ 4] = 12 ;
prtinfo->pi_dmatrix[ 5] =  4 ;
prtinfo->pi_dmatrix[ 6] = 14 ;
prtinfo->pi_dmatrix[ 7] =  6 ;
prtinfo->pi_dmatrix[ 8] =  3 ;
prtinfo->pi_dmatrix[ 9] = 11 ;
prtinfo->pi_dmatrix[10] =  1 ;
prtinfo->pi_dmatrix[11] =  9 ;
prtinfo->pi_dmatrix[12] = 14 ; /* bug 15 !! */
prtinfo->pi_dmatrix[13] =  7 ;
prtinfo->pi_dmatrix[14] = 13 ;
prtinfo->pi_dmatrix[15] =  5 ;
Le printer.device utilise une trame 4x4, qui permet de représenter 16 nuances d'une couleur. Comme une imprimante couleur utilise 3 couleurs Cyan Magenta Jaune, on obtient 16x16x16 = 4096 couleurs, exactement ce que l'Amiga est capable de fournir. Malheureusement la théorie, n'a rien à voir avec la pratique, car les couleurs de l'écran ne sont pas toutes imprimables. De plus pour du vrai noir, il faut une couleur noire, car si on mélange CMJ, on obtient du marron peu ragoutant.

Plus de couleurs!
Pour représenter plus de couleurs on va envisager une trame 8x8, pour représenter 256 nuances (et ainsi 256x256x256 = 16 millions de couleurs), répartie par le même algorithme de remplissage utilisé par la 4x4.
82168125153 94164113149
196 7227 54200 11231 58
102129 70184105141 74180
243 39211 23247 43215 27
90160117145 86172121156
204 15235 62192 3223 51
109137 78176 98133 66188
251 47219 31239 35207 19
D'où le code suivant

static UBYTE dither_matrix8x8[64] =
{  82, 168, 125, 153,  94, 164, 113, 149,
  196,   7, 227,  54, 200,  11, 231,  58,
  102, 129,  70, 184, 105, 141,  74, 180,
  243,  39, 211,  23, 247,  43, 215,  27,
   90, 160, 117, 145,  86, 172, 121, 156,
  204,  15, 235,  62, 192,   3, 223,  51,
  109, 137,  78, 176,  98, 133,  66, 188,
  251,  47, 219,  31, 239,  35, 207,  19
} ;

UBYTE dither8( UBYTE v, UWORD x, UWORD y, UBYTE pen1, UBYTE pen2 )
{
  if (v < dither_matrix8x8[x & 0x07][y & 0x07])
  {
    return pen1 ;
  }
  return pen2 ;
} /* dither8 */
v est l'intensité de la couleur, x, y les coordonnées du point (point physique sur le papier), pen1 la couleur si l'intensité est trop faible, pen2 autrement.

Et le printer.device dans tout ça ?
Soit on utilise des remplacements comme TurboPrint, soit on ruse. Il est possible de supprimer la trame 4x4, en passant les 2400 points par ligne directement dans le pilote de l'imprimante, tout en utilisant le printer.device. Pour s'en convaincre, regarder le code de DirectDump, du paquet anaiis_print.lha sur Aminet. DirectDump détourne proprement certaines fonctions internes (et peu documentées) du printer.device pour envoyer les points souhaités à l'imprimante. On garde ainsi le printer.device et les pilotes originaux, mais on imprime en vraies 256 nuances, soit quasiment en 24 bits par couleurs.

Séquence action
Voici un petit dessin en 256 couleurs qui nous servira de référence pour nos essais.

En imprimant l'image de référence avec les pilotes d'origine, on obtient ceci

Ce n'est pas terrible.
- la taille des pixels n'est pas respectée, d'où les distorsions.
- les couleurs 3 (255,0,0) et 4 (255, 9, 0), 5 (255, 17,0) et 6 (255, 26, 0), 7 (255,34,0) et 8 (255, 43, 0), et d'autres sont identiques ce qui met en évidence une limitation à 3x4=12bits.

En imprimant avec DirectDump en 12bits (trame ordonnée 4x4)

On retrouve les mêmes problèmes de limitation au niveau des couleurs, mais c'est normal, on est en 12 bits.
En imprimant avec DirectDump en 24 bits (trame trame ordonnée 8x8)

Et bien ça devient intéressant:
Les couleurs 3 et 4 ont bien des trames différentes, ainsi que toutes les autres. Sur du vrai papier, on ne voit pas trop la différence pour des petits carrés, mais sur des dégradés, il y a une énorme différence... je vous laisse vous amuser avec DirectDump, sachant qu'il peut ingurgiter des images QRT (le format d'images de rendu produit par l'ancêtre de PovRay) Une page A4 représente déjà 24Mo en 300x300...

Conclusion
L'Amiga, malgré son âge plus que respectable, a été bien conçu, et reste évolutif même si on peut prendre ces efforts bidouillesques comme des exploits. Cette machine me surprendra tous les jours... quoiqu'en ce moment elle ne me surprend que les weekends pluvieux...