0.20191016: LibImthreshold: fix Clamp

Author: zvezdochiot

Makefile

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

doc/imthreshold/CHANGELOG

@@ -1,3 +1,8 @@
+0.20191016
+
+    LibImthreshold: fix Clamp
+    RIS: add: FRP upscale
+
 0.20191013
 
     RIS: add: GSample upscale

doc/imthreshold/VERSION

@@ -1 +1 @@
-0.20191013
+0.20191016

man/man1/imthreshold-shris.1

@@ -14,8 +14,9 @@ imthreshold-shris [options] <input_file> <output_file>
 .TP
 -f str
 name filter:
-    'hris'
+    'hris' (default)
     'gsample'
+    'frp' (long!)
 .TP
 -m
 mode (int, optional, default = 2, {2,{3(hris),all(gsample)}})

src/imthreshold.c

@@ -14,24 +14,24 @@ double RADGRD = 57.295779513082320876798154814105;
 
 BYTE ByteClamp(int c)
 {
-    BYTE buff[3] = {0, (BYTE)c, 255};
-    return buff[ (int)(c > 0) + (int)(c > 255) ];
+    BYTE buff[3] = {(BYTE)c, 255, 0};
+    return buff[ (int)(c < 0) + (int)((unsigned)c > 255) ];
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 WORD Byte3Clamp(int c)
 {
-    WORD buff[3] = {0, (WORD)c, 765};
-    return buff[ (int)(c > 0) + (int)(c > 765) ];
+    WORD buff[3] = {(WORD)c, 765, 0};
+    return buff[ (int)(c < 0) + (int)((unsigned)c > 765) ];
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 unsigned IndexClamp(int i, unsigned threshold)
 {
-    unsigned buff[3] = {0, (unsigned)i, threshold};
-    return buff[ (int)(i > 0) + (int)(i > threshold) ];
+    unsigned buff[3] = {(unsigned)i, threshold, 0};
+    return buff[ (int)(i < 0) + (int)((unsigned)i > threshold) ];
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -6339,6 +6339,89 @@ void IMTFilterSNearest (IMTpixel** p_im, IMTpixel** d_im, unsigned height, unsig
 
 ////////////////////////////////////////////////////////////////////////////////
 
+void IMTFilterSFRP (IMTpixel** p_im, IMTpixel** d_im, unsigned height, unsigned width, int smode)
+{
+    unsigned y, x, yf, xf, ys, xs, ysf, xsf, ym, xm, yr, xr, d, k, l, bpp = 3, r = 1, rd = (2 * r + 1);
+    unsigned widths, heights, imdm, imdt, imdms = (512 * bpp * rd * rd);
+    int im, ims, imd;
+    IMTpixel **s_im, **r_im;
+
+    if (smode < 2) {smode = 2;}
+    heights = (height + smode - 1) / smode;
+    widths = (width + smode - 1) / smode;
+    s_im = IMTalloc(heights, widths);
+    r_im = IMTalloc(rd, rd);
+    IMTFilterSReduce(p_im, s_im, height, width, smode);
+
+    for (y = 0; y < height; y++)
+    {
+        yr = y * smode;
+        for (x = 0; x < width; x++)
+        {
+            xr = x * smode;
+            for (k = 0; k < rd; k++)
+            {
+                yf = IndexClamp(((int)(y + k) - r), (height - 1));
+                for (l = 0; l < rd; l++)
+                {
+                    xf = IndexClamp(((int)(x + l) - r), (width - 1));
+                    r_im[k][l] = p_im[yf][xf];
+                }
+            }
+            ym = 0;
+            xm = 0;
+            imdm = imdms;
+            for (ys = 0; ys < heights; ys++)
+            {
+                for (xs = 0; xs < widths; xs++)
+                {
+                    imdt = 0;
+                    for (k = 0; k < rd; k++)
+                    {
+                        ysf = IndexClamp(((int)(ys + k) - r), (heights - 1));
+                        for (l = 0; l < rd; l++)
+                        {
+                            xsf = IndexClamp(((int)(xs + l) - r), (widths - 1));
+                            im = r_im[k][l].s;
+                            ims = s_im[ysf][xsf].s;
+                            imd = (im > ims) ? (im - ims) : (ims - im);
+                            imdt += imd;
+                            for (d = 0; d < bpp; d++)
+                            {
+                                im = r_im[k][l].c[d];
+                                ims = s_im[ysf][xsf].c[d];
+                                imd = (im > ims) ? (im - ims) : (ims - im);
+                                imdt += imd;
+                            }
+                        }
+                    }
+                    if (imdt < imdm)
+                    {
+                        ym = ys;
+                        xm = xs;
+                        imdm = imdt;
+                    }
+                }
+            }
+            ym *= smode;
+            xm *= smode;
+            for (k =  0; k < smode; k++)
+            {
+                yf = IndexClamp((ym + k), (height - 1));
+                for (l =  0; l < smode; l++)
+                {
+                    xf = IndexClamp((xm + l), (width - 1));
+                    d_im[yr + k][xr + l] = p_im[yf][xf];
+                }
+            }
+        }
+    }
+    IMTfree(r_im, rd);
+    IMTfree(s_im, heights);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 int IMTFilterThreshold (IMTpixel** p_im, BYTE** d_im, unsigned height, unsigned width, int threshold)
 {
     unsigned y, x;

src/imthreshold.h

@@ -177,6 +177,7 @@ void IMTFilterSHRIS (IMTpixel**, IMTpixel**, unsigned, unsigned, int);
 void IMTFilterSGSampleUp (IMTpixel**, IMTpixel**, unsigned, unsigned, int);
 void IMTFilterSReduce (IMTpixel**, IMTpixel**, unsigned, unsigned, unsigned);
 void IMTFilterSNearest (IMTpixel**, IMTpixel**, unsigned, unsigned, unsigned, unsigned);
+void IMTFilterSFRP (IMTpixel** p_im, IMTpixel** d_im, unsigned height, unsigned width, int smode);
 int IMTFilterThreshold (IMTpixel**, BYTE**, unsigned, unsigned, int);
 int IMTFilterThresholdLayer (IMTpixel**, WORD**, BYTE**, unsigned, unsigned);
 void IMTFilterTLayerToImg (WORD**, IMTpixel**, unsigned, unsigned);

src/shris.cpp

@@ -24,8 +24,9 @@ void ImthresholdFilterSHRISUsage()
     printf("Usage : imthreshold-shris [options] <input_file> <output_file>\n\n");
     printf("options:\n");
     printf("          -f str  name filter:\n");
-    printf("                    'hris'\n");
+    printf("                    'hris' (default)\n");
     printf("                    'gsample'\n");
+    printf("                    'frp' (long!)\n");
     printf("          -m      mode (int, optional, default = 2, {2,3})\n");
     printf("          -r      reduce scale (bool, optional)\n");
     printf("          -h      this help\n");
@@ -82,7 +83,7 @@ int main(int argc, char *argv[])
     const char *output_filename = argv[optind + 1];
 
     if (smode < 2) {smode = 2;}
-    if (strcmp(namefilter, "hris") == 0)
+    if ((strcmp(namefilter, "gsample") > 0) && (strcmp(namefilter, "frp") > 0) && !(reduce))
     {
         if (smode > 3) {smode = 3;}
     }
@@ -101,8 +102,6 @@ int main(int argc, char *argv[])
             unsigned width2;
             unsigned height2;
             printf("Mode= %d\n", smode);
-            width2 = width * smode;
-            height2 = height * smode;
             if (reduce > 0)
             {
                 width2 = (width + smode - 1) / smode;
@@ -127,6 +126,9 @@ int main(int argc, char *argv[])
                 {
                     printf("Scale= Up GSample.\n");
                     IMTFilterSGSampleUp(p_im, d_im, height, width, smode);
+                } else if (strcmp(namefilter, "frp") == 0) {
+                    printf("Scale= Up FRP.\n");
+                    IMTFilterSFRP(p_im, d_im, height, width, smode);
                 } else {
                     printf("Scale= Up HRIS.\n");
                     IMTFilterSHRIS(p_im, d_im, height, width, smode);