Overview

1. First, generate a white noise pattern.
2. Convert the white noise pattern to a blue noise pattern using the void-and-cluster method.
   The following processes are repeated. It is a heavy process that takes about 10 minutes when it reaches about 256 × 256.
   A Gaussian filter is used for the low-pass filter.
   
   1. Obtain the cyclic convolution of the low-frequency component using an appropriate low-pass filter.
      It must be "cyclic" to avoid issues with the boundary. In general, the cyclic convolution is processed using fft→ifft, but our library uses a regular integral process. There is no problem because a fast algorithm is used for the second and subsequent cyclic convolutions.
   2. Get and remove the coordinates of "1" = cluster at the maximum value of the low-frequency component.
   3. Obtain the cyclic convolution of the low-frequency component using an appropriate low-pass filter based on the inverted image.
   4. Get the coordinates of "0" = void at the maximum value of the low-frequency component and change it to "1".
   5. Repeat until there are no cluster/void pairs that can be changed.
3. Generate a matrix for organized dither from the blue noise pattern. This is a heavy process that takes more time than the void-and-cluster method.
   

Constructor

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

Create Single Plane Blue Noise Mask

// Create a blue noise matrix
// Input
//  int     width;      Mask width (in pixels)
//  int     height;     Mask height (in pixels)
//  int     level;      Number of tones in the original image plane (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
//  0....Normal completion
//  Negative...Error (defined in errcode.h, only MEMORY_SHORTAGE(-1000) error)
int makebluenoisematrix(int width, int height, int level = 256, int ws = 7, double sigma = 1.5);

Create Multiplane Blue Noise Mask

// Input
//  int      componentnum;     Number of planes (3 for RGB, 4 for CMYK. Up to 9 possible.
//                             For a larger number of planes, it is recommended to execute with 128x128 or 256x256 for improved quality)
// Return value
//  0....Normal termination
//	Negative...Error
int				mseparatebluenoisematrix(int componentnum);

Save and Load Instance Data

// Intermediate state save/load
// Inputs
//  char*       filename;   File name
int             msavebnm(char* filename);
int             mloadbnm(char* filename);
void			mclearwork();

// Creating a 256×256 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
// Later use
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
// Performs ordered dithering using the generated matrix
//     (Typically, the matrix is obtained by the application and used for dithering)
// Input
// The image is a 256-level image for one plane
//  int             no;             Specifies the plane number of the mask to be used (0 to plane number - 1)
//                                  Specifying the same plane number results in dot-on-dot blue noise matrix processing
//                                  For RGB, it does not have to be R=0, G=1, B=2. Any combination is acceptable.
//  int             width;          Width of the image (in pixels)
//  int             height;         Height of the image (in pixels)
//  int             scanlinesize1;  Number of bytes in one line of the image
//  unsigned char*  pdata1;         256-level image
//  int             scanlinesize2;  Number of bytes in one line of the output 2/4-level image
// Output
//  unsigned char*  pdata2;         2/4-level image
//                                  Returns (0/255) for 2-level, and (0/85/170/255) for 4-level.
//                                  The library is not limited to one plane with 256 levels, but this is a debug utility, so it takes shortcuts
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
//     Version that processes one line at a time
// Input
//   int            y;               Line number
//   Other arguments are the same as 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;
                // Greater than or equal to the matrix value (threshold or above)
                if(ps3[x] <= *ps1) {
                    *ps2 = 255;
                }
                else {
                    *ps2 = 0;
                }
            }
        }
    }
    else {
        mppchild[no]->mordereddither2(0, width, height, scanlinesize1, pdata1, scanlinesize2, pdata2);
    }
}

Execution of Error Diffusion Method

// Error diffusion program for quality and speed comparison
// Floyd & Steinberg method
// Input
// The image is a single plane image (for 256-shade images)
// For RGB, the process is performed three times for each plane
//  int             width;          width of the image (in pixels)
//  int             height;         height of the image (in pixels)
//  int             scanlinesize1;  byte size of one line of the image
//  unsigned char*  pdata1;         256-shade image
//  float*          pdata2;         work area for calculations, requires sizeof(float) * width * height bytes
// Output
//  unsigned char*  pdata3;         2/4-shade 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);

Fast Execution

CBNMask* pbn = new CBNMask();       // Constructor
↓
CBNMaskFast* pbn = new CBNMaskFast();       // Constructor

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