Hi,
I have tried making 4-lvl grayscale but it looks too flickery sometimes. I was wondering of an easy way to make it less flickery.
Right now I have it alternate between 3 pictures very fast. The first pic just shows what is pure black on the picture and what is white. The second one shows the black being either black or dark gray and white being white. The third picture shows the black being being black, dark gray, or light gray and the white being white.
Is there a way to have 4-lvl grayscale still look good but not so flickery?
I have tried blurring an image using 50% dithering but it seems that I can only get 1 shade of gray, not two. If I try using, say, 25% or 75% dithering then it looks obvious that I am dithering the picture. I want it to look a solid gray, not a dithered gray. It only looks solid if I just use 50% dithering, which is half of the pixels are white, half black.

Hopefully that made any sense.
Thanks, and have a nice day,
nxtboy III

I think he wants axe (Am I right?)

What device would that be?

Ah interesting!  Well to get better grey, not only should you make sure you actually are matching the refresh rate of the screen, but you also probably should try to get dither to work.  Greyscale works because the average color over the course of several frames of animations is not a black or white color.  Dither increases greyscale quality because the average color of a section of screen is made to be grey in every single frame, not just over the course of many frames.  In addition, every pixel of the same color must be dithered in the same rate and in a constant fashion so splotches don't appear. 

For example, you noted that 50% dithering worked really well, correct?  This is where you would draw a checkerboard one frame, and then draw a shifted checkerboard the next frame such that you drew on all the pixels that were not drawn on the previous.  In this way each frame contains 50% black and 50% white, and over the course of many frames all pixels get an even and consistent distribution of black and white. 

Doing this with 33% and 66% (as 4level has 4 color, 0% 33% 66% and 100%) is a bit trickier, but still can be accomplished.  If we look back on our checkerboard example, we can look at the checkerboard as consisting of sections of 2x2 pixels like so:

10      01
01      10
The first and second frame work together to each contain 50% grey.  With 4 level greyscale, we need to make a larger box:

100     010     001
010     001     100
001     100     010
This represents the 3x3 box of 33% grey.  There are 3 steps to this animation, and therefore achieving 33% (1/3) grey is easy.  As you can see, each pixel is on only once in the course of the animation, and the frames are displayed in an orderly fashion, which makes everything look smoother.  66% grey would be achieved in much the same way.

Now the tricky part is this; When you are making your greyscale drawings, you are not going to be making them out of 3x3 blocks.  What you need to do is imagine the 3x3 blocks span all the way across the screen.  An array of 3x3 blocks for each color.  1 repeating pattern for 0% 33% 66% and 100%.  Whenever you want to color a pixel, you select the pixels from the 3x3 block that corresponds to that pixel.  If you wanted to color the pixel at (1,1) to 33% grey, it's color pattern would be 1 on the first frame of animation, and 0 on the second and third.  The pixel at location (4,0) however, would have the pattern 0,1,0.

Using this technique, coupled with matching the refresh rate precisely, can lead your greyscale images to be smooth and as least flicker-y as possible.

You can either use 3 images, or if you want to decrease the total size (but increase the complexity of display) generate the 3 images dynamically from an image that actually does have 4 colors.  This would be a bit more complicated, but decrease the size of the programs you write, which may or may not be a problem for you, I am not familiar with NXT programming size constraints. 

One issue with trying to match the screen refresh rate, however, is that on some devices, it's not the same across all of them. For example, one TI-84 Plus may have a different refresh rate than another TI-84 Plus. I wouldn't be surprised if it was the same for Lego Mindstorm NXT devices.

If you get able to test your grayscale on two such devices and the grayscale quality looks different on both, then it might be a good idea to do like certain calculator grayscale games and add a calibration option at the start of your program.

unfortunately nope. Scanlines and checkerboards are the only way grayscale is done by members here really.

There is no pattern that I know of that is not moving diagonal lines.  You could experiment with different types of animations, but what is interesting is that if you keep with the idea that (for 33%) there should only be 1 pixel on per row and column in the 3x3 pattern at any time, there is no way to scramble around the pixels, or animation to prevent some sort of scrolling line effect.

Also, see if displaying the images faster results in better greyscale, it is possible the refresh rate is faster than you think!  And if the refresh rate is significantly slow, and the LCD of high enough quality, this effect will not work as well as it does on our TI calculators.