Overview

1. Initially, generate a white noise pattern.
2. Convert the white noise pattern into a blue noise pattern using the void-and-cluster method.
   The following process is repeated. For a size of about 256ﾃ・56, this is a computationally intensive process taking tens of minutes.
   A Gaussian filter is used as the low-pass filter.
   
   1. Obtain the cyclic convolution of low-frequency components using an appropriate low-pass filter.
      If it is not "cyclic," the boundary areas will become inconsistent. Cyclic convolution is commonly processed with fft竊段fft; however, this library simplifies it with standard integral processing. A fast algorithm is used for subsequent cyclic convolutions, so there are no issues.
   2. Obtain the coordinates of the "1" (cluster) with the maximum low-frequency component and remove it.
   3. Using the inverted image, obtain the cyclic convolution of low-frequency components with an appropriate low-pass filter.
   4. Obtain the coordinates of the "0" (void) with the maximum low-frequency component and change it to "1".
   5. Repeat until there are no more pairs of clusters/voids that can be modified.
3. Generate a matrix for ordered dithering from the blue noise pattern.
   This is even more computationally intensive than the void-and-cluster method.
   

Constructor

CBNMask* pbn = new CBNMask();       // Constructor
.....
delete pbn;                         // Destructor

Single-Plane Blue Noise Mask Creation

// Create a blue noise matrix
// Input
//  int     width;      Mask width (in pixels)
//  int     height;     Mask height (in pixels)
//  int     level;      Number of gradation levels in one plane of the source image (default value: 256)
//  int     ws;         Gaussian filter window size (default value: 7 (7x7 window))
//  double  sigma;      Standard deviation of the Gaussian filter (default value: 1.5)
// Return Value
//  0....Success
//  Negative...Error (as described in errcode.h; only MEMORY_SHORTAGE (-1000) error is handled)
int         makebluenoisematrix(int width,int height,int level = 256,int ws = 7,double sigma = 1.5);

Multi-Plane Blue Noise Mask Creation

// Input
//  int      componentnum;     Number of planes (3 for RGB, 4 for CMYK, maximum 9).
//                             For a larger number of planes, using 128ﾃ・28 or 256ﾃ・56 improves quality.
// Return Value
//  0....Success
//  Negative...Error
int             mseparatebluenoisematrix(int componentnum);

Saving and Loading Instance Data

// Save/Load intermediate results
// Input
//  char*       filename;   File name
int             msavebnm(char* filename);
int             mloadbnm(char* filename);
void            mclearwork();

// Create a 256ﾃ・56 matrix
CBNMask* pbn = new CBNMask();       // Constructor
int i1 = pbn->makebluenoisematrix(256,256);
if(i1 < 0) {
    delete pbn;
    // Error handling
}
i1 = pbn->msavebnm("c:\tmp\256x256.bnm");
if(i1 < 0) {
    delete pbn;
    // Error handling
}
delete pbn;                         // Destructor
// Use later
CBNMask* pbn = new CBNMask();       // Constructor
int i1 = pbn->mloadbnm("c:\\tmp\\256x256.bnm");
if(i1 < 0) {
    delete pbn;
    // Error handling
}
.....
delete pbn;                         // Destructor

Execution of Ordered Dithering

// 1...Ordered Dither Utility
// Executes ordered dithering using the generated matrix
//     (Normally, the application retrieves the matrix and performs dithering)
// Input
// The image is a single-plane image (256 grayscale levels)
//  int             no;             Specifies the plane number of the mask to use (0 to number of planes - 1).
//                                  Using the same plane number results in dot-on-dot blue noise matrix processing.
//                                  For RGB, R is not necessarily 0, G is not necessarily 1, B is not necessarily 2; any combination is allowed.
//  int             width;          Width of the image (in pixels)
//  int             height;         Height of the image (in pixels)
//  int             scanlinesize1;  Number of bytes per line of the input image
//  unsigned char*  pdata1;         256 grayscale image
//  int             scanlinesize2;  Number of bytes per line of the output 2/4 grayscale image
// Output
//  unsigned char*  pdata2;         2/4 grayscale image
//                                  For 2 levels, returns (0/255); for 4 levels, returns (0/85/170/255).
//                                  The library is not limited to 256 grayscale levels per plane, but this is simplified for debugging purposes.
void            mordereddither2(int no,int width,int height,int scanlinesize1,unsigned char* pdata1,
                        int scanlinesize2,unsigned char* pdata2);
void            mordereddither4(int no,int width,int height,int scanlinesize1,unsigned char* pdata1,
                        int scanlinesize2,unsigned char* pdata2);
// 2...Ordered Dither Utility
//     Line-by-line processing version
// Input
//   int            y;               Line number
//   Other arguments are the same as for mordereddither2/mordereddither4
void            morderedditherline2(int no,int width,int y,unsigned char* pdata1,unsigned char* pdata2);
void            morderedditherline4(int no,int width,int y,unsigned char* pdata1,unsigned char* pdata2);

void CBNMask::mordereddither2(int no,int width,int height,int scanlinesize1,unsigned char* pdata1,
                        int scanlinesize2,unsigned char* pdata2)
{
    if(mcomponentnum == 1) {
        int            total = mwidth * mheight;
        for(int i = 0 ; i < height ; i++) {
            unsigned char*  ps1 = pdata1 + scanlinesize1 * i;
            unsigned char*  ps2 = pdata2 + scanlinesize2 * i;
            int             y = i % mheight;
            unsigned int*   ps3 = mpmatrix + mwidth * y;
            for(int j = 0 ; j < width ; j++,ps1++,ps2++) {
                int            x = j % mwidth;
                // If the matrix value is greater than or equal to the pixel value (threshold)
                if(ps3[x] <= *ps1) {
                    *ps2 = 255;
                }
                else {
                    *ps2 = 0;
                }
            }
        }
    }
    else {
        mppchild[no]->mordereddither2(0,width,height,scanlinesize1,pdata1,scanlinesize2,pdata2);
    }
}

Execution of Error Diffusion

// Error diffusion program for quality and speed comparison
// Floyd & Steinberg method
// Input
// The image is a single-plane image (256 grayscale levels only).
// For RGB, process each plane three times.
//  int             width;          Width of the image (in pixels)
//  int             height;         Height of the image (in pixels)
//  int             scanlinesize1;  Number of bytes per line of the image
//  unsigned char*  pdata1;         256 grayscale image
//  float*          pdata2;         Work area for computation, requires sizeof(float) * width * height bytes
// Output
//  unsigned char*  pdata3;         2/4 grayscale image
void            mfloydsteinberg2(int width,int height,int scanlinesize1,unsigned char* pdata1,float* pdata2,unsigned char* pdata3);
void            mfloydsteinberg4(int width,int height,int scanlinesize1,unsigned char* pdata1,float* pdata2,unsigned char* pdata3);

Execution of the High-Speed Version

CBNMask* pbn = new CBNMask();       // Constructor
竊・
CBNMaskFast* pbn = new CBNMaskFast();       // Constructor

• For 8 planes, approximately 8192ﾃ・192 on a machine with 12GB of memory. 2^26
  
• For 4 planes, approximately 8192ﾃ・192 on a machine with 8GB of memory. 2^26
  
• For grayscale, approximately 8192ﾃ・192 on a machine with 6GB of memory. 2^26
  
• For grayscale, approximately 16384ﾃ・6384 on a machine with 16GB of memory. 2^28
  
• For 3 planes, approximately 16384ﾃ・6384 on a machine with 24GB of memory.