0.20190917: Filter: add: quant

Author: zvezdochiot

Makefile

@@ -5,7 +5,7 @@ CPP           = g++
 CFLAGS        = -DUNIX -O2 -Wall -s
 LIBS          = -lfreeimage
 VER           = 0
-VERB          = 20190824
+VERB          = 20190917
 PLIBF         = lib$(PNAME).so.$(VER)
 PLIBFI        = lib$(PNAME)freeimage.so.$(VER)
 PLIB          = $(PLIBF) $(PLIBFI)

README.md

@@ -13,15 +13,15 @@ Main directions:
  3) HRIS - image scaling up.
  ![Half Reverse Interpolation Scale](https://github.com/zvezdochiot/imthreshold/blob/master/images/hris_small.jpg)
 
- 2016 zvezdochiot.
- 
+ 2016-2019 zvezdochiot.
+
  2006-2016 monday2000.
- 
+
  Website: https://sourceforge.net/projects/imthreshold/
- 
+
  GIT: https://github.com/ImageProcessing-ElectronicPublications/imthreshold
- 
+
  BookScanLib.ru Website: http://djvu-soft.narod.ru/
- 
+
  Email: zvezdochiot@users.sourceforge.net
- 
+

doc/imthreshold/BUILD

@@ -45,4 +45,4 @@ This program is free software;
 You can redistribute it and/or
 modify it under the terms of the Zlib License.
 
-Copyright (C) 2016 zvezdochiot.
+Copyright (C) 2016-2019 zvezdochiot.

doc/imthreshold/CHANGELOG

@@ -1,3 +1,7 @@
+0.20190917
+
+    Filter: add: quant
+
 0.20190824
 
     LibImthreshold: extern C

doc/imthreshold/VERSION

@@ -1 +1 @@
-0.20190824
+0.20190917

src/filter.cpp

@@ -47,6 +47,7 @@ void ImthresholdFilterUsage()
     printf("                    'none' (default)\n");
     printf("                    'peron'\n");
     printf("                    'posterize'\n");
+    printf("                    'quant'\n");
     printf("                    'retinex'\n");
     printf("                    'rs'\n");
     printf("                    'selgauss'\n");
@@ -489,6 +490,20 @@ int main(int argc, char *argv[])
                 dst_dib = FreeImage_Allocate(width, height, 24);
                 ImthresholdSetData(dst_dib, p_im);
                 IMTfree(p_im, height);
+            } else if (strcmp(namefilter, "quant") == 0) {
+                printf("Filter= %s\n", namefilter);
+                double imsh = 0;
+                IMTpixel** p_im = IMTalloc(height, width);
+
+                if (posterdiv < 1) {posterdiv = 1;}
+                printf("Quant= %d\n", posterdiv);
+                ImthresholdGetData(dib, p_im);
+                FreeImage_Unload(dib);
+                imsh = IMTFilterQuant(p_im, height, width, posterdiv);
+                printf("Delta= %f\n", imsh);
+                dst_dib = FreeImage_Allocate(width, height, 24);
+                ImthresholdSetData(dst_dib, p_im);
+                IMTfree(p_im, height);
             } else if (strcmp(namefilter, "retinex") == 0) {
                 printf("Filter= %s\n", namefilter);
                 int radiusint;

src/imthreshold.c

@@ -13,25 +13,25 @@ double RADGRD = 57.295779513082320876798154814105;
 ////////////////////////////////////////////////////////////////////////////////
 
 BYTE ByteClamp(int c)
-{ 
-    BYTE buff[3] = {(BYTE)c, 255, 0};
-    return buff[ (c < 0) + ((unsigned)c > 255) ];
+{
+    BYTE buff[3] = {0, (BYTE)c, 255};
+    return buff[ (int)(c > 0) + (int)(c > 255) ];
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 WORD Byte3Clamp(int c)
-{ 
-    WORD buff[3] = {(WORD)c, 765, 0};
-    return buff[ (c < 0) + ((unsigned)c > 765) ];
+{
+    WORD buff[3] = {0, (WORD)c, 765};
+    return buff[ (int)(c > 0) + (int)(c > 765) ];
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 unsigned IndexClamp(int i, unsigned threshold)
-{ 
-    unsigned buff[3] = {(unsigned)i, threshold, 0};
-    return buff[ (i < 0) + ((unsigned)i > threshold) ];
+{
+    unsigned buff[3] = {0, (unsigned)i, threshold};
+    return buff[ (int)(i > 0) + (int)(i > threshold) ];
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -722,7 +722,7 @@ unsigned IMTFilterDMag2 (BYTE** p_im, unsigned height, unsigned width, unsigned
     unsigned height2, width2, y, threshold;
     height2 = height * 2;
     width2 = width * 2;
-    
+
     BYTE** d_im = BWalloc(height2, width2);
 
     threshold = 0;
@@ -733,9 +733,9 @@ unsigned IMTFilterDMag2 (BYTE** p_im, unsigned height, unsigned width, unsigned
     }
     threshold /= Ksize;
     threshold /= 2;
-    
+
     BWfree(d_im, height2);
-    
+
     return threshold;
 }
 
@@ -2094,7 +2094,7 @@ void IMTFilterSeparateBGFGL (IMTpixel** p_im, BYTE** m_im, IMTpixel** fg_im, IMT
             bgdist = IMTdist(pim, bgim);
             m_im[y][x] = (BYTE)((fgdist < bgdist) ? 0 : 255);
         }
-    }       
+    }
 
     IMTfree(fgt_im, heightbg);
 }
@@ -2574,7 +2574,7 @@ void IMTFilterMathDivide (IMTpixel** p_im, IMTpixel** m_im, unsigned height, uns
                 imm = m_im[y][x].c[d];
                 imm++;
                 im /= imm;
-                im *= 256; 
+                im *= 256;
                 im += delta;
                 im -= 0.5;
                 p_im[y][x].c[d] = ByteClamp((int)im);
@@ -3651,6 +3651,85 @@ double IMTFilterPosterize (IMTpixel** p_im, unsigned height, unsigned width, uns
 
 ////////////////////////////////////////////////////////////////////////////////
 
+double IMTFilterQuant (IMTpixel** p_im, unsigned height, unsigned width, unsigned quant)
+{
+    unsigned y, x, d, k, l, n;
+    unsigned im, imt;
+    int imd;
+    unsigned histogram[256];
+    unsigned histthres[256];
+    unsigned histquant[256];
+    double histstep, histsum, histsumk, imds = 0.0;
+
+    quant = (quant > 0) ? quant : 1;
+    n = height * width;
+    n = (n > 0) ? n : 1;
+    histstep = (double)n;
+    histstep /= quant;
+    for (d = 0; d < 3; d++)
+    {
+        for (k = 0; k < 256; k++)
+        {
+            histogram[k] = 0;
+            histthres[k] = 0;
+            histquant[k] = 0;
+        }
+        for (y = 0; y < height; y++)
+        {
+            for (x = 0; x < width; x++)
+            {
+                im = p_im[y][x].c[d];
+                histogram[im]++;
+            }
+        }
+        histsum = 0.0;
+        for (k = 0; k < 256; k++)
+        {
+            histsum += histogram[k];
+            l = (histsum > 0.0) ? (int)((histsum - 1.0)/ histstep) : 0;
+            histthres[k] = l;
+        }
+        for (l = 0; l < quant; l++)
+        {
+            histsum = 0;
+            histsumk = 0;
+            for (k = 0; k < 256; k++)
+            {
+                if (histthres[k] == l)
+                {
+                    histsum += histogram[k];
+                    histsumk += (histogram[k] * k);
+                }
+            }
+            histsumk = (histsum > 0) ? (histsumk / histsum) : histsumk;
+            for (k = 0; k < 256; k++)
+            {
+                if (histthres[k] == l)
+                {
+                    histquant[k] = histsumk;
+                }
+            }
+        }
+        for (y = 0; y < height; y++)
+        {
+            for (x = 0; x < width; x++)
+            {
+                im = p_im[y][x].c[d];
+                imt = histquant[im];
+                imd = (im < imt) ? (imt - im) : (im - imt);
+                p_im[y][x].c[d] = ByteClamp(imt);
+                imds += imd;
+            }
+        }
+    }
+    imds /= n;
+    imds /= 3;
+
+    return imds;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 void IMTFilterPMean (IMTpixel** p_im, IMTpixel** d_im, unsigned height, unsigned width, double radius, int fmode, bool fneared)
 {
     int y, x, i, j, rn, dy, dx;
@@ -4918,7 +4997,7 @@ double IMTFilterClusterBWC (IMTpixel** p_im, IMTpixel** d_im, unsigned height, u
         if (gpart == 0) {gpart = 1;}
         for (y = 0; y < height; y++)
         {
-            
+
             if (y <= radius) {y1 = 0;} else {y1 = y - radius;}
             y2 = y;
             y2 += radius;
@@ -5521,7 +5600,7 @@ void IMTFilterSBicont (IMTpixel** p_im, IMTpixel** d_im, unsigned height, unsign
                 {
                     pdist[k] += sdist;
                     pdist[k] = sdist / pdist[k];
-                     
+
                     pdist[k] -= 0.5;
                     zdist = (pdist[k] < 0.0) ? -1.0: 1.0;
                     pdist[k] *= zdist;
@@ -6225,7 +6304,7 @@ int IMTFilterThresholdLayer (IMTpixel** p_im, WORD** t_im, BYTE** d_im, unsigned
     imts /= height;
     imts /= width;
     threshold = (int)(imts + 0.5);
-    
+
     return threshold;
 }
 
@@ -6704,7 +6783,7 @@ int IMTFilterTBiModValue (IMTpixel** p_im, unsigned height, unsigned width)
 int IMTFilterTBiMod (IMTpixel** p_im, BYTE** d_im, unsigned height, unsigned width, int delta)
 {
     int threshold = 0;
-    
+
     threshold = IMTFilterTBiModValue (p_im, height, width);
     threshold += delta;
     threshold = IMTFilterThreshold (p_im, d_im, height, width, threshold);
@@ -8198,7 +8277,7 @@ int IMTFilterTMscaleLayer (IMTpixel** p_im, WORD** t_im, unsigned height, unsign
                     for (x = x0; x < x1; x++)
                     {
                         if (p_im[y][x].s < immin) {immin = p_im[y][x].s;}
-                        if (p_im[y][x].s > immax) {immax = p_im[y][x].s;}                       
+                        if (p_im[y][x].s > immax) {immax = p_im[y][x].s;}
                     }
                 }
                 immean = immax + immin;
@@ -8438,7 +8517,7 @@ int IMTFilterTQuadModValue (IMTpixel** p_im, unsigned height, unsigned width)
 int IMTFilterTQuadMod (IMTpixel** p_im, BYTE** d_im, unsigned height, unsigned width, int delta)
 {
     int threshold = 0;
-    
+
     threshold = IMTFilterTQuadModValue (p_im, height, width);
     threshold += delta;
     threshold = IMTFilterThreshold (p_im, d_im, height, width, threshold);

src/imthreshold.h

@@ -28,7 +28,7 @@
 #define MAX(a,b)  ((a) > (b) ? (a) : (b))
 #endif
 #ifndef TRIM
-#define TRIM(x,a,b) (FA_MIN(FA_MAX(x,a),b))
+#define TRIM(x,a,b) (MIN(FA_MAX((x),(a)),(b)))
 #endif
 
 typedef uint8_t  BYTE;
@@ -149,6 +149,7 @@ IMTpixel IMTmeanMaxIcM (IMTpixel**, IMTpixel, bool**, unsigned, unsigned, unsign
 int IMTFilterKMeans (IMTpixel**, unsigned, unsigned, unsigned, unsigned);
 void IMTFilterPeron (IMTpixel**, IMTpixel**, unsigned, unsigned, double, double);
 double IMTFilterPosterize (IMTpixel**, unsigned, unsigned, unsigned);
+double IMTFilterQuant (IMTpixel**, unsigned, unsigned, unsigned);
 void IMTFilterPMean (IMTpixel**, IMTpixel**, unsigned, unsigned, double, int, bool);
 int IMTFilterRetinex (IMTpixel**, IMTpixel**, unsigned, unsigned, int, double);
 double IMTFilterRS (IMTpixel**, unsigned, unsigned);