Dither a Grayscale Image
GraphicsMagick/ImageMagick
Ordered Dither:
magick B2DBy.jpg -gamma .45455 -ordered-dither [all] 4x4 ordered4x4g45.pbm
Before complaining about my using an "established algorithm" please read the ChangeLog for GraphicsMagick and ImageMagick for April 2003 where you'll see that I implemented the algorithm in those applications. Also, the combination of "-gamma .45455" with "-ordered-dither" is new.
The "-gamma .45455" takes care of the image being too light. The "all" parameter is only needed with GraphicsMagick.
There's banding because there are only 17 graylevels in a 4x4 ordered-dither image. The appearance of banding can be reduced by using an 8x8 ordered-dither which has 65 levels.
Here are the original image, the 4x4 and 8x8 ordered dithered output and the random-threshold output:
I prefer the ordered-dither version, but am including the random-threshold version for completeness.
magick B2DBy.jpg -gamma .6 -random-threshold 10x90% random-threshold.pbm
The "10x90%" means to render below 10 percent intensity pixels as pure black and above 90 percent as pure white, to avoid having a few lonely specks in those areas.
It's probably worth noting that both are as memory-efficient as they can possibly be. Neither does any diffusion, so they work one pixel at a time, even when writing ordered-dither blocks, and don't need to know anything about the neighboring pixels. ImageMagick and GraphicsMagick process a row at a time, but it's not necessary for these methods. The ordered-dither conversions take less than .04 second real time on my old x86_64 computer.
I apologize for the code style, I threw this together using some libraries we just built in my java class, and it has a bad case of copy-paste and magic numbers. The algorithm picks random rectangles in the image, and checks if the average brightness is greater in the dithered image or the original image. It then turns a pixel on or off to bring the brightnesses closer in line, preferentially picking pixels that are more different from the original image. I think it does a better job bringing out thin details like the puppy's hair, but the image is noisier because it tries to bring out details even in areas with none.
public void dither(){
int count = 0;
ditheredFrame.suspendNotifications();
while(count < 1000000){
count ++;
int widthw = 5+r.nextInt(5);
int heightw = widthw;
int minx = r.nextInt(width-widthw);
int miny = r.nextInt(height-heightw);
Frame targetCropped = targetFrame.crop(minx, miny, widthw, heightw);
Frame ditherCropped = ditheredFrame.crop(minx, miny, widthw, heightw);
if(targetCropped.getAverage().getBrightness() > ditherCropped.getAverage().getBrightness() ){
int x = 0;
int y = 0;
double diff = 0;
for(int i = 1; i < ditherCropped.getWidth()-1; i ++){
for(int j = 1; j < ditherCropped.getHeight()-1; j ++){
double d = targetCropped.getPixel(i, j).getBrightness() - ditherCropped.getPixel(i, j).getBrightness();
d += .005* targetCropped.getPixel(i+1, j).getBrightness() - .005*ditherCropped.getPixel(i+1, j).getBrightness();
d += .005* targetCropped.getPixel(i-1, j).getBrightness() - .005*ditherCropped.getPixel(i-1, j).getBrightness();
d += .005* targetCropped.getPixel(i, j+1).getBrightness() -.005* ditherCropped.getPixel(i, j+1).getBrightness();
d += .005* targetCropped.getPixel(i, j-1).getBrightness() - .005*ditherCropped.getPixel(i, j-1).getBrightness();
if(d > diff){
diff = d;
x = i;
y = j;
}
}
ditherCropped.setPixel(x, y, WHITE);
}
} else {
int x = 0;
int y = 0;
double diff = 0;
for(int i = 1; i < ditherCropped.getWidth()-1; i ++){
for(int j = 1; j < ditherCropped.getHeight()-1; j ++){
double d = ditherCropped.getPixel(i, j).getBrightness() -targetCropped.getPixel(i, j).getBrightness();
d += -.005* targetCropped.getPixel(i+1, j).getBrightness() +.005* ditherCropped.getPixel(i+1, j).getBrightness();
d += -.005* targetCropped.getPixel(i-1, j).getBrightness() +.005* ditherCropped.getPixel(i+1, j).getBrightness();
d += -.005* targetCropped.getPixel(i, j+1).getBrightness() + .005*ditherCropped.getPixel(i, j+1).getBrightness();
d += -.005* targetCropped.getPixel(i, j-1).getBrightness() + .005*ditherCropped.getPixel(i, j-1).getBrightness();
if(d > diff){
diff = d;
x = i;
y = j;
}
}
ditherCropped.setPixel(x, y, BLACK);
}
}
}
ditheredFrame.resumeNotifications();
}
Fortran
Okay, I'm using an obscure image format called FITS which is used for astronomy. This means there is a Fortran library for reading and writing such images. Also, ImageMagick and Gimp can both read/write FITS images.
The algorithm I use is based on "Sierra Lite" dithering, but with two improvements:
a) I reduce the propagated error by a factor 4/5.
b) I introduce a random variation in the diffusion matrix while keeping its sum constant.
Together these almost completely elminiate the patterns seen in OPs example.
Assuming you have the CFITSIO library installed, compile with
gfortran -lcfitsio dither.f90
The file names are hard-coded (couldn't be bothered to fix this).
Code:
program dither
integer :: status,unit,readwrite,blocksize,naxes(2),nfound
integer :: group,npixels,bitpix,naxis,i,j,fpixel,un
real :: nullval,diff_mat(3,2),perr
real, allocatable :: image(:,:), error(:,:)
integer, allocatable :: seed(:)
logical :: anynull,simple,extend
character(len=80) :: filename
call random_seed(size=Nrand)
allocate(seed(Nrand))
open(newunit=un,file="/dev/urandom",access="stream",&
form="unformatted",action="read",status="old")
read(un) seed
close(un)
call random_seed(put=seed)
deallocate(seed)
status=0
call ftgiou(unit,status)
filename='PUPPY.FITS'
readwrite=0
call ftopen(unit,filename,readwrite,blocksize,status)
call ftgknj(unit,'NAXIS',1,2,naxes,nfound,status)
call ftgidt(unit,bitpix,status)
npixels=naxes(1)*naxes(2)
group=1
nullval=-999
allocate(image(naxes(1),naxes(2)))
allocate(error(naxes(1)+1,naxes(2)+1))
call ftgpve(unit,group,1,npixels,nullval,image,anynull,status)
call ftclos(unit, status)
call ftfiou(unit, status)
diff_mat=0.0
diff_mat(3,1) = 2.0
diff_mat(1,2) = 1.0
diff_mat(2,2) = 1.0
diff_mat=diff_mat/5.0
error=0.0
perr=0
do j=1,naxes(2)
do i=1,naxes(1)
p=max(min(image(i,j)+error(i,j),255.0),0.0)
if (p < 127.0) then
perr=p
image(i,j)=0.0
else
perr=p-255.0
image(i,j)=255.0
endif
call random_number(r)
r=0.6*(r-0.5)
error(i+1,j)= error(i+1,j) +perr*(diff_mat(3,1)+r)
error(i-1,j+1)=error(i-1,j+1)+perr*diff_mat(1,2)
error(i ,j+1)=error(i ,j+1) +perr*(diff_mat(2,2)-r)
end do
end do
call ftgiou(unit,status)
blocksize=1
filename='PUPPY-OUT.FITS'
call ftinit(unit,filename,blocksize,status)
simple=.true.
naxis=2
extend=.true.
call ftphpr(unit,simple,bitpix,naxis,naxes,0,1,extend,status)
group=1
fpixel=1
call ftppre(unit,group,fpixel,npixels,image,status)
call ftclos(unit, status)
call ftfiou(unit, status)
deallocate(image)
deallocate(error)
end program dither
Example output for the puppy image in OPs post:
OPs example output:
