With ITK 5.0, itk::ProcessObject::VerifyInputInformation are now declared const

[clitk.git] / utilities / CxImage / ximatran.cpp

diff --git a/utilities/CxImage/ximatran.cpp b/utilities/CxImage/ximatran.cpp
index d3aac0182ae0e0532080d1c4c72e4abcf7c110e7..dd635cf1185368b1a81311688bd02b540c21916f 100644 (file)
--- a/utilities/CxImage/ximatran.cpp
+++ b/utilities/CxImage/ximatran.cpp
@@ -282,12 +282,12 @@ bool CxImage::RotateLeft(CxImage* iDst)
                        for (ys = 0; ys < newHeight; ys+=RBLOCK) {
                                if (head.biBitCount==24) {
                                        //RGB24 optimized pixel access:
-                                       for (x = xs; x < min(newWidth, xs+RBLOCK); x++){    //do rotation
+                                       for (x = xs; x < __min(newWidth, xs+RBLOCK); x++){    //do rotation
                                                info.nProgress = (long)(100*x/newWidth);
                                                x2=newWidth-x-1;
                                                dstPtr = (BYTE*) imgDest.BlindGetPixelPointer(x,ys);
                                                srcPtr = (BYTE*) BlindGetPixelPointer(ys, x2);
-                                               for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
+                                               for (y = ys; y < __min(newHeight, ys+RBLOCK); y++){
                                                        //imgDest.SetPixelColor(x, y, GetPixelColor(y, x2));
                                                        *(dstPtr) = *(srcPtr);
                                                        *(dstPtr+1) = *(srcPtr+1);
@@ -298,19 +298,19 @@ bool CxImage::RotateLeft(CxImage* iDst)
                                        }//for x
                                } else {
                                        //anything else than 24bpp (and 1bpp): palette
-                                       for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
+                                       for (x = xs; x < __min(newWidth, xs+RBLOCK); x++){
                                                info.nProgress = (long)(100*x/newWidth); //<Anatoly Ivasyuk>
                                                x2=newWidth-x-1;
-                                               for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
+                                               for (y = ys; y < __min(newHeight, ys+RBLOCK); y++){
                                                        imgDest.SetPixelIndex(x, y, BlindGetPixelIndex(y, x2));
                                                }//for y
                                        }//for x
                                }//if (version selection)
 #if CXIMAGE_SUPPORT_ALPHA
                                if (AlphaIsValid()) {
-                                       for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
+                                       for (x = xs; x < __min(newWidth, xs+RBLOCK); x++){
                                                x2=newWidth-x-1;
-                                               for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
+                                               for (y = ys; y < __min(newHeight, ys+RBLOCK); y++){
                                                        imgDest.AlphaSet(x,y,BlindAlphaGet(y, x2));
                                                }//for y
                                        }//for x
@@ -323,9 +323,9 @@ bool CxImage::RotateLeft(CxImage* iDst)
                                        imgDest.info.rSelectionBox.right = newWidth-info.rSelectionBox.bottom;
                                        imgDest.info.rSelectionBox.bottom = info.rSelectionBox.left;
                                        imgDest.info.rSelectionBox.top = info.rSelectionBox.right;
-                                       for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
+                                       for (x = xs; x < __min(newWidth, xs+RBLOCK); x++){
                                                x2=newWidth-x-1;
-                                               for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
+                                               for (y = ys; y < __min(newHeight, ys+RBLOCK); y++){
                                                        imgDest.SelectionSet(x,y,BlindSelectionGet(y, x2));
                                                }//for y
                                        }//for x
@@ -427,12 +427,12 @@ bool CxImage::RotateRight(CxImage* iDst)
                        for (ys = 0; ys < newHeight; ys+=RBLOCK) {
                                if (head.biBitCount==24) {
                                        //RGB24 optimized pixel access:
-                                       for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
+                                       for (y = ys; y < __min(newHeight, ys+RBLOCK); y++){
                                                info.nProgress = (long)(100*y/newHeight); //<Anatoly Ivasyuk>
                                                y2=newHeight-y-1;
                                                dstPtr = (BYTE*) imgDest.BlindGetPixelPointer(xs,y);
                                                srcPtr = (BYTE*) BlindGetPixelPointer(y2, xs);
-                                               for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
+                                               for (x = xs; x < __min(newWidth, xs+RBLOCK); x++){
                                                        //imgDest.SetPixelColor(x, y, GetPixelColor(y2, x));
                                                        *(dstPtr) = *(srcPtr);
                                                        *(dstPtr+1) = *(srcPtr+1);
@@ -443,19 +443,19 @@ bool CxImage::RotateRight(CxImage* iDst)
                                        }//for y
                                } else {
                                        //anything else than BW & RGB24: palette
-                                       for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
+                                       for (y = ys; y < __min(newHeight, ys+RBLOCK); y++){
                                                info.nProgress = (long)(100*y/newHeight); //<Anatoly Ivasyuk>
                                                y2=newHeight-y-1;
-                                               for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
+                                               for (x = xs; x < __min(newWidth, xs+RBLOCK); x++){
                                                        imgDest.SetPixelIndex(x, y, BlindGetPixelIndex(y2, x));
                                                }//for x
                                        }//for y
                                }//if
 #if CXIMAGE_SUPPORT_ALPHA
                                if (AlphaIsValid()){
-                                       for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
+                                       for (y = ys; y < __min(newHeight, ys+RBLOCK); y++){
                                                y2=newHeight-y-1;
-                                               for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
+                                               for (x = xs; x < __min(newWidth, xs+RBLOCK); x++){
                                                        imgDest.AlphaSet(x,y,BlindAlphaGet(y2, x));
                                                }//for x
                                        }//for y
@@ -468,9 +468,9 @@ bool CxImage::RotateRight(CxImage* iDst)
                                        imgDest.info.rSelectionBox.right = info.rSelectionBox.top;
                                        imgDest.info.rSelectionBox.bottom = newHeight-info.rSelectionBox.right;
                                        imgDest.info.rSelectionBox.top = newHeight-info.rSelectionBox.left;
-                                       for (y = ys; y < min(newHeight, ys+RBLOCK); y++){
+                                       for (y = ys; y < __min(newHeight, ys+RBLOCK); y++){
                                                y2=newHeight-y-1;
-                                               for (x = xs; x < min(newWidth, xs+RBLOCK); x++){
+                                               for (x = xs; x < __min(newWidth, xs+RBLOCK); x++){
                                                        imgDest.SelectionSet(x,y,BlindSelectionGet(y2, x));
                                                }//for x
                                        }//for y
@@ -588,10 +588,10 @@ bool CxImage::Rotate(float angle, CxImage* iDst)
        newP4.x = (float)(p4.x*cos_angle - p4.y*sin_angle);
        newP4.y = (float)(p4.x*sin_angle + p4.y*cos_angle);
 
-       leftTop.x = min(min(newP1.x,newP2.x),min(newP3.x,newP4.x));
-       leftTop.y = min(min(newP1.y,newP2.y),min(newP3.y,newP4.y));
-       rightBottom.x = max(max(newP1.x,newP2.x),max(newP3.x,newP4.x));
-       rightBottom.y = max(max(newP1.y,newP2.y),max(newP3.y,newP4.y));
+       leftTop.x = __min(__min(newP1.x,newP2.x),__min(newP3.x,newP4.x));
+       leftTop.y = __min(__min(newP1.y,newP2.y),__min(newP3.y,newP4.y));
+       rightBottom.x = __max(__max(newP1.x,newP2.x),__max(newP3.x,newP4.x));
+       rightBottom.y = __max(__max(newP1.y,newP2.y),__max(newP3.y,newP4.y));
        leftBottom.x = leftTop.x;
        leftBottom.y = rightBottom.y;
        rightTop.x = rightBottom.x;
@@ -720,10 +720,10 @@ bool CxImage::Rotate2(float angle,
        }//if
 
        //(read new dimensions from location of corners)
-       float minx = (float) min(min(newp[0].x,newp[1].x),min(newp[2].x,newp[3].x));
-       float miny = (float) min(min(newp[0].y,newp[1].y),min(newp[2].y,newp[3].y));
-       float maxx = (float) max(max(newp[0].x,newp[1].x),max(newp[2].x,newp[3].x));
-       float maxy = (float) max(max(newp[0].y,newp[1].y),max(newp[2].y,newp[3].y));
+       float minx = (float) __min(__min(newp[0].x,newp[1].x),__min(newp[2].x,newp[3].x));
+       float miny = (float) __min(__min(newp[0].y,newp[1].y),__min(newp[2].y,newp[3].y));
+       float maxx = (float) __max(__max(newp[0].x,newp[1].x),__max(newp[2].x,newp[3].x));
+       float maxy = (float) __max(__max(newp[0].y,newp[1].y),__max(newp[2].y,newp[3].y));
        int newWidth = (int) floor(maxx-minx+0.5f);
        int newHeight= (int) floor(maxy-miny+0.5f);
        float ssx=((maxx+minx)- ((float) newWidth-1))/2.0f;   //start for x
@@ -983,12 +983,12 @@ bool CxImage::Resample(long newx, long newy, int mode, CxImage* iDst)
                                if (info.nEscape) break;
                                fY = y * yScale;
                                ifY = (int)fY;
-                               ifY1 = min(ymax, ifY+1);
+                               ifY1 = __min(ymax, ifY+1);
                                dy = fY - ifY;
                                for(long x=0; x<newx; x++){
                                        fX = x * xScale;
                                        ifX = (int)fX;
-                                       ifX1 = min(xmax, ifX+1);
+                                       ifX1 = __min(xmax, ifX+1);
                                        dx = fX - ifX;
                                        // Interpolate using the four nearest pixels in the source
                                        if (head.biClrUsed){
@@ -1308,9 +1308,9 @@ bool CxImage::DecreaseBpp(DWORD nbit, bool errordiffusion, RGBQUAD* ppal, DWORD
                                eb=(long)c.rgbBlue - (long)ce.rgbBlue;
 
                                c = GetPixelColor(x+1,y);
-                               c.rgbRed = (BYTE)min(255L,max(0L,(long)c.rgbRed + ((er*7)/16)));
-                               c.rgbGreen = (BYTE)min(255L,max(0L,(long)c.rgbGreen + ((eg*7)/16)));
-                               c.rgbBlue = (BYTE)min(255L,max(0L,(long)c.rgbBlue + ((eb*7)/16)));
+                               c.rgbRed = (BYTE)__min(255L,__max(0L,(long)c.rgbRed + ((er*7)/16)));
+                               c.rgbGreen = (BYTE)__min(255L,__max(0L,(long)c.rgbGreen + ((eg*7)/16)));
+                               c.rgbBlue = (BYTE)__min(255L,__max(0L,(long)c.rgbBlue + ((eb*7)/16)));
                                SetPixelColor(x+1,y,c);
                                int coeff=1;
                                for(int i=-1; i<2; i++){
@@ -1323,9 +1323,9 @@ bool CxImage::DecreaseBpp(DWORD nbit, bool errordiffusion, RGBQUAD* ppal, DWORD
                                                coeff=1; break;
                                        }
                                        c = GetPixelColor(x+i,y+1);
-                                       c.rgbRed = (BYTE)min(255L,max(0L,(long)c.rgbRed + ((er * coeff)/16)));
-                                       c.rgbGreen = (BYTE)min(255L,max(0L,(long)c.rgbGreen + ((eg * coeff)/16)));
-                                       c.rgbBlue = (BYTE)min(255L,max(0L,(long)c.rgbBlue + ((eb * coeff)/16)));
+                                       c.rgbRed = (BYTE)__min(255L,__max(0L,(long)c.rgbRed + ((er * coeff)/16)));
+                                       c.rgbGreen = (BYTE)__min(255L,__max(0L,(long)c.rgbGreen + ((eg * coeff)/16)));
+                                       c.rgbBlue = (BYTE)__min(255L,__max(0L,(long)c.rgbBlue + ((eb * coeff)/16)));
                                        SetPixelColor(x+i,y+1,c);
                                }
                        }
@@ -1546,10 +1546,10 @@ bool CxImage::Dither(long method)
                                }
 
                                nlevel = GetPixelIndex(x + 1, y) + (error * 8) / TotalCoeffSum;
-                               level = (BYTE)min(255, max(0, (int)nlevel));
+                               level = (BYTE)__min(255, __max(0, (int)nlevel));
                                SetPixelIndex(x + 1, y, level);
                                nlevel = GetPixelIndex(x + 2, y) + (error * 4) / TotalCoeffSum;
-                               level = (BYTE)min(255, max(0, (int)nlevel));
+                               level = (BYTE)__min(255, __max(0, (int)nlevel));
                                SetPixelIndex(x + 2, y, level);
                                int i;
                                for (i = -2; i < 3; i++) {
@@ -1571,7 +1571,7 @@ bool CxImage::Dither(long method)
                                                break;
                                        }
                                        nlevel = GetPixelIndex(x + i, y + 1) + (error * coeff) / TotalCoeffSum;
-                                       level = (BYTE)min(255, max(0, (int)nlevel));
+                                       level = (BYTE)__min(255, __max(0, (int)nlevel));
                                        SetPixelIndex(x + i, y + 1, level);
                                }
                        }
@@ -1600,10 +1600,10 @@ bool CxImage::Dither(long method)
                                }
 
                                nlevel = GetPixelIndex(x + 1, y) + (error * 8) / TotalCoeffSum;
-                               level = (BYTE)min(255, max(0, (int)nlevel));
+                               level = (BYTE)__min(255, __max(0, (int)nlevel));
                                SetPixelIndex(x + 1, y, level);
                                nlevel = GetPixelIndex(x + 2, y) + (error * 4) / TotalCoeffSum;
-                               level = (BYTE)min(255, max(0, (int)nlevel));
+                               level = (BYTE)__min(255, __max(0, (int)nlevel));
                                SetPixelIndex(x + 2, y, level);
                                int i;
                                for (i = -2; i < 3; i++) {
@@ -1625,7 +1625,7 @@ bool CxImage::Dither(long method)
                                                break;
                                        }
                                        nlevel = GetPixelIndex(x + i, y + 1) + (error * coeff) / TotalCoeffSum;
-                                       level = (BYTE)min(255, max(0, (int)nlevel));
+                                       level = (BYTE)__min(255, __max(0, (int)nlevel));
                                        SetPixelIndex(x + i, y + 1, level);
                                }
                                for (i = -2; i < 3; i++) {
@@ -1647,7 +1647,7 @@ bool CxImage::Dither(long method)
                                                break;
                                        }
                                        nlevel = GetPixelIndex(x + i, y + 2) + (error * coeff) / TotalCoeffSum;
-                                       level = (BYTE)min(255, max(0, (int)nlevel));
+                                       level = (BYTE)__min(255, __max(0, (int)nlevel));
                                        SetPixelIndex(x + i, y + 2, level);
                                }
                        }
@@ -1676,10 +1676,10 @@ bool CxImage::Dither(long method)
                                }
 
                                nlevel = GetPixelIndex(x + 1, y) + (error * 7) / TotalCoeffSum;
-                               level = (BYTE)min(255, max(0, (int)nlevel));
+                               level = (BYTE)__min(255, __max(0, (int)nlevel));
                                SetPixelIndex(x + 1, y, level);
                                nlevel = GetPixelIndex(x + 2, y) + (error * 5) / TotalCoeffSum;
-                               level = (BYTE)min(255, max(0, (int)nlevel));
+                               level = (BYTE)__min(255, __max(0, (int)nlevel));
                                SetPixelIndex(x + 2, y, level);
                                int i;
                                for (i = -2; i < 3; i++) {
@@ -1701,7 +1701,7 @@ bool CxImage::Dither(long method)
                                                break;
                                        }
                                        nlevel = GetPixelIndex(x + i, y + 1) + (error * coeff) / TotalCoeffSum;
-                                       level = (BYTE)min(255, max(0, (int)nlevel));
+                                       level = (BYTE)__min(255, __max(0, (int)nlevel));
                                        SetPixelIndex(x + i, y + 1, level);
                                }
                                for (i = -2; i < 3; i++) {
@@ -1723,7 +1723,7 @@ bool CxImage::Dither(long method)
                                                break;
                                        }
                                        nlevel = GetPixelIndex(x + i, y + 2) + (error * coeff) / TotalCoeffSum;
-                                       level = (BYTE)min(255, max(0, (int)nlevel));
+                                       level = (BYTE)__min(255, __max(0, (int)nlevel));
                                        SetPixelIndex(x + i, y + 2, level);
                                }
                        }
@@ -1752,10 +1752,10 @@ bool CxImage::Dither(long method)
                                }
 
                                nlevel = GetPixelIndex(x + 1, y) + (error * 5) / TotalCoeffSum;
-                               level = (BYTE)min(255, max(0, (int)nlevel));
+                               level = (BYTE)__min(255, __max(0, (int)nlevel));
                                SetPixelIndex(x + 1, y, level);
                                nlevel = GetPixelIndex(x + 2, y) + (error * 3) / TotalCoeffSum;
-                               level = (BYTE)min(255, max(0, (int)nlevel));
+                               level = (BYTE)__min(255, __max(0, (int)nlevel));
                                SetPixelIndex(x + 2, y, level);
                                int i;
                                for (i = -2; i < 3; i++) {
@@ -1777,7 +1777,7 @@ bool CxImage::Dither(long method)
                                                break;
                                        }
                                        nlevel = GetPixelIndex(x + i, y + 1) + (error * coeff) / TotalCoeffSum;
-                                       level = (BYTE)min(255, max(0, (int)nlevel));
+                                       level = (BYTE)__min(255, __max(0, (int)nlevel));
                                        SetPixelIndex(x + i, y + 1, level);
                                }
                                for (i = -1; i < 2; i++) {
@@ -1793,7 +1793,7 @@ bool CxImage::Dither(long method)
                                                break;
                                        }
                                        nlevel = GetPixelIndex(x + i, y + 2) + (error * coeff) / TotalCoeffSum;
-                                       level = (BYTE)min(255, max(0, (int)nlevel));
+                                       level = (BYTE)__min(255, __max(0, (int)nlevel));
                                        SetPixelIndex(x + i, y + 2, level);
                                }
                        }
@@ -1825,76 +1825,76 @@ bool CxImage::Dither(long method)
                                int tmp_index_y = y;
                                int tmp_coeff = 32;
                                nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
-                               level = (BYTE)min(255, max(0, (int)nlevel));
+                               level = (BYTE)__min(255, __max(0, (int)nlevel));
                                SetPixelIndex(tmp_index_x, tmp_index_y, level);
 
                                tmp_index_x = x - 3;
                                tmp_index_y = y + 1;
                                tmp_coeff = 12;
                                nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
-                               level = (BYTE)min(255, max(0, (int)nlevel));
+                               level = (BYTE)__min(255, __max(0, (int)nlevel));
                                SetPixelIndex(tmp_index_x, tmp_index_y, level);
 
                                tmp_index_x = x - 1;
                                tmp_coeff = 26;
                                nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
-                               level = (BYTE)min(255, max(0, (int)nlevel));
+                               level = (BYTE)__min(255, __max(0, (int)nlevel));
                                SetPixelIndex(tmp_index_x, tmp_index_y, level);
 
                                tmp_index_x = x + 1;
                                tmp_coeff = 30;
                                nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
-                               level = (BYTE)min(255, max(0, (int)nlevel));
+                               level = (BYTE)__min(255, __max(0, (int)nlevel));
                                SetPixelIndex(tmp_index_x, tmp_index_y, level);
 
                                tmp_index_x = x + 3;
                                tmp_coeff = 16;
                                nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
-                               level = (BYTE)min(255, max(0, (int)nlevel));
+                               level = (BYTE)__min(255, __max(0, (int)nlevel));
                                SetPixelIndex(tmp_index_x, tmp_index_y, level);
 
                                tmp_index_x = x - 2;
                                tmp_index_y = y + 2;
                                tmp_coeff = 12;
                                nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
-                               level = (BYTE)min(255, max(0, (int)nlevel));
+                               level = (BYTE)__min(255, __max(0, (int)nlevel));
                                SetPixelIndex(tmp_index_x, tmp_index_y, level);
 
                                tmp_index_x = x;
                                tmp_coeff = 26;
                                nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
-                               level = (BYTE)min(255, max(0, (int)nlevel));
+                               level = (BYTE)__min(255, __max(0, (int)nlevel));
                                SetPixelIndex(tmp_index_x, tmp_index_y, level);
 
                                tmp_index_x = x + 2;
                                tmp_coeff = 12;
                                nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
-                               level = (BYTE)min(255, max(0, (int)nlevel));
+                               level = (BYTE)__min(255, __max(0, (int)nlevel));
                                SetPixelIndex(tmp_index_x, tmp_index_y, level);
 
                                tmp_index_x = x - 3;
                                tmp_index_y = y + 3;
                                tmp_coeff = 5;
                                nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
-                               level = (BYTE)min(255, max(0, (int)nlevel));
+                               level = (BYTE)__min(255, __max(0, (int)nlevel));
                                SetPixelIndex(tmp_index_x, tmp_index_y, level);
 
                                tmp_index_x = x - 1;
                                tmp_coeff = 12;
                                nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
-                               level = (BYTE)min(255, max(0, (int)nlevel));
+                               level = (BYTE)__min(255, __max(0, (int)nlevel));
                                SetPixelIndex(tmp_index_x, tmp_index_y, level);
 
                                tmp_index_x = x + 1;
                                tmp_coeff = 12;
                                nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
-                               level = (BYTE)min(255, max(0, (int)nlevel));
+                               level = (BYTE)__min(255, __max(0, (int)nlevel));
                                SetPixelIndex(tmp_index_x, tmp_index_y, level);
 
                                tmp_index_x = x + 3;
                                tmp_coeff = 5;
                                nlevel = GetPixelIndex(tmp_index_x, tmp_index_y) + (error * tmp_coeff) / TotalCoeffSum;
-                               level = (BYTE)min(255, max(0, (int)nlevel));
+                               level = (BYTE)__min(255, __max(0, (int)nlevel));
                                SetPixelIndex(tmp_index_x, tmp_index_y, level);
                        }
                }
@@ -1921,7 +1921,7 @@ bool CxImage::Dither(long method)
                        Bmatrix[i] = (BYTE)(dither);
                }
 
-               int scale = max(0,(8-2*order));
+               int scale = __max(0,(8-2*order));
                int level;
                for (long y=0;y<head.biHeight;y++){
                        info.nProgress = (long)(100*y/head.biHeight);
@@ -1961,7 +1961,7 @@ bool CxImage::Dither(long method)
                                }
 
                                nlevel = GetPixelIndex(x+1,y) + (error * 7)/16;
-                               level = (BYTE)min(255,max(0,(int)nlevel));
+                               level = (BYTE)__min(255,__max(0,(int)nlevel));
                                SetPixelIndex(x+1,y,level);
                                for(int i=-1; i<2; i++){
                                        switch(i){
@@ -1973,7 +1973,7 @@ bool CxImage::Dither(long method)
                                                coeff=1; break;
                                        }
                                        nlevel = GetPixelIndex(x+i,y+1) + (error * coeff)/16;
-                                       level = (BYTE)min(255,max(0,(int)nlevel));
+                                       level = (BYTE)__min(255,__max(0,(int)nlevel));
                                        SetPixelIndex(x+i,y+1,level);
                                }
                        }
@@ -2011,7 +2011,7 @@ bool CxImage::CropRotatedRectangle( long topx, long topy, long width, long heigh
        if ( fabs(angle)<0.0002 )
                return Crop( topx, topy, topx+width, topy+height, iDst);
 
-       startx = min(topx, topx - (long)(sin_angle*(double)height));
+       startx = __min(topx, topx - (long)(sin_angle*(double)height));
        endx   = topx + (long)(cos_angle*(double)width);
        endy   = topy + (long)(cos_angle*(double)height + sin_angle*(double)width);
        // check: corners of the rectangle must be inside
@@ -2059,10 +2059,10 @@ bool CxImage::Crop(long left, long top, long right, long bottom, CxImage* iDst)
 {
        if (!pDib) return false;
 
-       long startx = max(0L,min(left,head.biWidth));
-       long endx = max(0L,min(right,head.biWidth));
-       long starty = head.biHeight - max(0L,min(top,head.biHeight));
-       long endy = head.biHeight - max(0L,min(bottom,head.biHeight));
+       long startx = __max(0L,__min(left,head.biWidth));
+       long endx = __max(0L,__min(right,head.biWidth));
+       long starty = head.biHeight - __max(0L,__min(top,head.biHeight));
+       long endy = head.biHeight - __max(0L,__min(bottom,head.biHeight));
 
        if (startx==endx || starty==endy) return false;