Image -> Ascii conversion algorithm idea

I was thinking (honest! .. it DOES happen *g*) when I saw JavaJulia by RMG (the
Geiss-guy) that the same algorith he uses to convert julia-fractals to ascii
could also be used for any graphic.

JavaJulia uses the chars " ,._'/)J`(\L"7PO" to creates neat Julia fractals.
(Btw he could have used � and many other extended chars since the medium was a
webpage)

I have been studing the code (because I thought it was intriguing and I wanted
to learn how he did it) and it seems that for each char it determines if 4
points are a part of the fractal (white) or if they are not.
Depending on which points are white and which are not it represents theese
points with a certain char from the chars mentioned earlier.

Some examples :
   __
  |##|  = 7
  | #|

   __
  |  |  = _
  |##|

   __
  |##|  = O
  |##|

Knowing this we can create a similar effect to any black & white image.
This works great for illustration and other graphics in only 2 colors.

But what is we wanted to apply this to a grayscale image (256 shades of grey) ?

I had an idea that if we instead assigned a value (0 - 255) to theese points
instead of just 0-1 (black or white) we could apply the above technique
(choosing the right char) to thoose points (pixels) IF and only if the
difference in brightness (0 - 255) was above a certain level (user adjustable)
and if not then the points brightness value would instead be averaged and a
"soft" char would be choosen to shade the area.
With soft char i mean a char without a distinctive shape .. like f.x :  #8Oo:.
( possibly userdefinable too ) ..

It's all very much like a mix between Jave's 4-pixel and 1-pixel algorithm.

I believe that this algorithm will yield very good results on illustrations and
high-contrast/low-detail images.

RFC

Sincerly
CeeJay

Christian 'CeeJay' Jensen wrote:
> 
> I was thinking (honest! .. it DOES happen *g*) when I saw JavaJulia by RMG (the
> Geiss-guy) that the same algorith he uses to convert julia-fractals to ascii
> could also be used for any graphic.
> 
> JavaJulia uses the chars " ,._'/)J`(\L"7PO" to creates neat Julia fractals.
> (Btw he could have used � and many other extended chars since the medium was a
> webpage)

Ok, now I you are on the best way to find out something I did not tell
many people so far, I am going to blab out how the generic tools in Jave
1.0 work. Well, I will not tell you how exactly it works but you should
be able to see the idea when doing the following:

  Start Jave, chose one of the (green) generic tools. Chose "Thick1" as
style (should be easiest with this one, though it works with others).
Begin painting, but keep the mouse pressed so you can see the (blue)
preview. Now press and hold the Ctrl-Key while still holdinging the
mouse button.

Now you should see how it works. :-)
In Jave 1.0 there are only two generic conversion algorithms. If you
still want to find out more about them, have a look at
jave/code/convert.txt and /jave/code/convert_thick.txt. But I am not
going to tell you more about this all.

In Jave 1.1 there will be one additional style for generic tools: "Dot"
                                       .........
           ..'''''''..           ..''''         ''''..
        .''           ''.      .'                     '.
      .'                 '.    :                       :
     :                     :    '..                 ..'
    :                       :      ''''.........''''
   :                         :
   :                         :        .'''''.
   '    ......               :      .'       '.
     .''      ''..          .'     :           :.
    .'            :        .'    .'             '':
   .'              :      .'    :
  .'                '.   '   .''
                      '''''''

I have also tested the style with JFL7."_ etc., but it does not work
well with those tools:

                                  ,__
     ________.                 ,_"'  "".
   _"        `_              ,/'       ".
  /            ".           /'          ).
 ,'             `"_       _"             `_
                   "____""                 "_ ,_
                                             "'
So you can see: I have tried those algorithms on tools - in fact you
already have used them without knowing (if you have worked with Jave)
:-)

But I have not integrated them into the image2ascii converter yet :-/
There are so many things to be done... :(
Be patient, Jave1.1 will be released soon :)

Markus
--
http://www.jave.de