I believe you're trying to represent a small restrict set of colors with one 16-bit Unicode char, right?
However, you also wish to throw in some transparency variations among them, don't you?

Since we have all of the Unicode characters at our dispose,
we have to find similar groups w/ small variation among them.

Thinking it over, vowels generally have many diacritics which can be used on them.
With 5 capital vowels + 5 non-capital vowels, we have a total of 10 different colors.

You can have each type of diacritic representing a level of opacity:
á, à, â, ã, ä.  <- each one is the same color w/ different alphaness.  
a w/o any diacritics would be total opaque.

Well, that's my idea!  

hello,

thanks.

Actually I have some old data I want to use.
The old data has 16 colors afaik and one for
transparent.

I don't intend to write new data that way....

I just don't know how to say

1. PImage.set(transparent);

Or is transparent the default?

Thanks!

When color() or a web color such as #B0A0C0 are used,
They auto-include a 100% opaque value.

That is, #B0A0C0 actually means -> 0x FFB0A0C0; after parsed by the pre-processor.

As you see, the easiest way to fully control transparency would be using a real hexadecimal literal w/ 0x.

Now, if you wanna modify the alpha byte w/o modifying its color,
you'd need to use a technique called masking.

For that, you have to read the color of a pixel and mold the far-left 8 bits from it.

I'm not good on it; but here's an attempt sample:

background(#B0A0C0);

PImage bg = get();

color pixel = bg.get(10, 10);
println( hex(pixel) );

short opacity = 150;   // alpha value to be used

pixel &= 0x00FFFFFF;   // resets alpha value
println( hex(pixel) );

pixel |= opacity<<030; // places desired new alpha value
println( hex(pixel) );

bg.set(10, 10, pixel); // same color w/ different opacity

exit();

P.S.: Seems like get() & set() completely ignore the alpha byte received/passed.
It is always 0xFF!  

Here's the proof:

final short x = 20, y = 10, opacity = 150;
background(#B0A0C0);
PImage bg = get();

println( hex(bg.get(x, y)) );
bg.set( x, y, bg.get(x, y) & 0x00FFFFFF | opacity<<030 );
println( hex(bg.get(x, y)) );

exit();

I guess I was successful while using pixels[] instead of get() & set().
Check it out:

/**
 * Change Alpha Pixel (v3.3)
 * by GoToLoop(2013/Feb)
 * 
 * http://forum.processing.org/topic/have-pimages-via-createimage-with-transparent-pixel
 */

final short x = 20, y = 10, opacity = 0200;
final color alphaMask = opacity<<030 | 0xFFFFFF;

background(#E7A0C5);

final int pos = width*y + x;
println(pos);

loadPixels();

println( hex(pixels[pos]) );
pixels[pos] &= alphaMask;
println( hex(pixels[pos]) );

updatePixels();

exit();

Example above is bugged!  
It only works when previous pixel's alpha is already 0xFF (100% opaque).

For it to work at any alpha value, 1st we have to zero that from pixel;
only then we can apply the Or mask:

/**
 * Change Alpha Pixel (v3.8)
 * by GoToLoop(2013/Feb)
 * 
 * http://forum.processing.org/topic/have-pimages-via-createimage-with-transparent-pixel
 */

final short x = 20, y = 10, opacity = 0200;
final color alphaMask = opacity<<030;

background(#E7A0C5);
PImage bg = get();

final int pos = bg.width*y + x;
println(pos);

bg.loadPixels();
println( hex(bg.pixels[pos]) );

// resets alpha then applies an Or mask:
bg.pixels[pos] = bg.pixels[pos] & 0xFFFFFF | alphaMask;

bg.updatePixels();

bg.loadPixels();  // reloads for alpha value change proof
println( hex(bg.pixels[pos]) ); // reads pixel color via pixels[] (Correct Result!)
println( hex(bg.get(x, y)) );   // reads pixel color via get() (Wrong Result!!!)

exit();

The easiest way to do this is to create a 'color palette' - an array of 16 integers to store the colour values, define which palette index is to be treated as the transparent colour and set the alpha for that colour to zero.

To get the image use createGraphics to create the PGraphics of the correct size. Then loop through the string data and convert each character into a palette index (0-15) then set the pixel to that matching palette colour.

All this can be done in setup before which leaves the draw method free to just display them.

This is the approach I took in the code below (I have not included the string data because there is no need) and it produced the image on the right. I may have got some of the colours wrong when crerating the palette but I will leave that for you to solve.

1. int[] colorPalette = new int[16];
2. String pchar = "0123456789ABCDEF";
3. ArrayList<PGraphics> imgs = new ArrayList<PGraphics>();
4. 
   
5. void createPalette(int alphaColor) {
6.   colorPalette = new int[16];
7.   for (int i = 0; i < colorPalette.length; i++) {
8.     switch(i) {
9.     case 0:
10.     case 1:
11.       colorPalette[i] = color (0, 255, 0);
12.       break;
13.     case 2:
14.     case 3:
15.     case 4:
16.     case 5:
17.       colorPalette[i] = color (0, 255, 0) ;
18.       break;
19.     case 6:
20.       // brown
21.       colorPalette[i] = color (234, 152, 28);
22.       break;
23.     case 7:
24.       colorPalette[i] = color (0, 0, 255);
25.       break;
26.     case 8:
27.       colorPalette[i] = color (235, 30, 2) ;
28.       break;
29.     case 9:
30.       colorPalette[i] = color (255, 0, 2);
31.       break;
32.     case 10:
33.       colorPalette[i] = color (255, 30, 2);
34.       break;
35.     case 11:
36.       colorPalette[i] = color (235, 30, 2);
37.       break;
38.     case 12:
39.     case 13:
40.       colorPalette[i] = color (0, 255, 0);
41.       break;
42.     case 14:
43.       colorPalette[i] = color (0, 255, 0);
44.       break;
45.     case 15:
46.     default:
47.       colorPalette[i] = color (255, 0, 2);
48.       break;
49.     }
50.     // Make this one transparent
51.     colorPalette[alphaColor] &= 0x00ffffff;
52.   }
53. }
54. 
    
55. void makePicture(String[] name, int[] palette) {
56.   int rows = name.length;
57.   int cols = name[0].length(); // should all be the same length
58.   int nbrPixels = rows * cols;
59.   PGraphics img = createGraphics(cols, rows);
60.   img.beginDraw();
61.   img.loadPixels();
62.   int p = 0;
63.   for (int i=0; i < rows; i++) {
64.     for (int j=0; j < cols; j++) {
65.       int idx = pchar.indexOf(name[i].charAt(j));
66.       println(idx);
67.       img.pixels[p] = palette[idx];
68.       p++;
69.     }
70.   }
71.   img.updatePixels();
72.   img.endDraw();
73.   imgs.add(img);
74. }
75. 
    
76. void setup() {
77.   size (700, 700);
78.   createPalette(7);
79.   makePicture(c1, colorPalette);
80.   makePicture(City, colorPalette);
81.   makePicture(village, colorPalette);
82.   makePicture(Dorf2, colorPalette);
83.   makePicture(Schaf1, colorPalette);
84.   makePicture(Schaf3, colorPalette);
85.   makePicture(Schaf4, colorPalette);
86.   makePicture(Schafbestes5, colorPalette);
87.   makePicture(Scharf7, colorPalette);
88.   makePicture(Schaf8, colorPalette);
89.   makePicture(zweiSchafeUebereinander, colorPalette);
90.   makePicture(zweiSchafeUebereinander2, colorPalette);
91.   makePicture(Ziegenbock, colorPalette);
92.   makePicture(baum, colorPalette);
93.   makePicture(Baum3, colorPalette);
94.   makePicture(BAUM4, colorPalette);
95.   makePicture(Baum7, colorPalette);
96.   makePicture(Sonne, colorPalette);
97. }
98. 
    
99. void draw() {
100.   background(240, 240, 200);
101.   for (int i = 0; i < imgs.size(); i++) {
102.     int x = 20 + (i % 5) * 40;
103.     int y = 20 + 40 * (i /5);
104.     image(imgs.get(i), x, y);
105.   }
106. }

you guys are just great!

Thank you both so much for that.

It would have taken me ages to figure that out.