'******************************************************************
' Advanced Windows Graphics in BCX by Kevin Diggins Aug 2006
' Includes derivative works from Manuel Augusto Nogueira dos Santos
' Mike Henning, Emil Halimg and other unnamed authors.
'******************************************************************
'  1  hBm = Sharpen(hBm)
'  2  hBm = Soften(hBm)
'  3  hBm = Blur(hBm)
'  4  hBm = Negative(hBm)
'  5  hBm = GrayScale(hBm)
'  6  hBm = WaterColor(hBm)
'  7  hBm = Contrast(hBm[,Factor])       Defaults to 10
'  8  hBm = Brightness(hBm[,Factor])     Defaults to 10
'  9  hBm = Gamma(hBm,Percent)           Percent = -100 to +100
' 10  hBm = Saturate(hBm,Percent)        Percent = -100 to +100
' 11  hBm = Diffuse(hBm[,Factor])        Factor Defaults to 10
' 12  hBm = EdgeEnhance(hBm[,Factor])    Factor Defaults to 10
' 13  hBm = Emboss(hBm[,RGB)])           RGB Defaults to Gray
' 14  hBm = EmbossMore(hBm[,RGB)])       RGB Defaults to Gray
' 15  hBm = Engrave ((hBm[,RGB)])        RGB Defaults to Gray
' 16  hBm = Contour(hBm[,RGB)])          RGB Defaults to White
' 17  hBm = EnhancedDiffusionBW(hBm)
' 18  hBm = OutlineShadow(hBm)
' 19  hBm = EngraveMore (hBm)
' 20  hBm = ConnectedContour(hBm)
' 21  hBm = Relief(hBm)
' 22  hBm = Dilate(hBm)
' 23  hBm = Erode(hBm)
' 24  hBm = DropShadow(hBm)
' 25  hBm = AntiAlias(hBm)
' 26  hBm = Blend (hBm1, hBm2)
' 27  hBM = OvalFrame (hBm1,[RGB])       RGB Defaults to White
' 28  hBm = Shape(hBm1, hBm2, [RGB})     RGB Defaults to Green
' 29  hBm = Gradient (W,H,TopRGB,BotRGB)
' 30  hBm = Convolve3x3(hBm,&Kernel[,Scalar][,Bias])
' 31  hBm = Convolve5x5(hBm,&Kernel[,Scalar][,Bias])
' 32  hBm = RotateBmp(hBm, Angle!, clrBack AS COLORREF)
' 33  hBm = MirrorBmp hBm [,FlipType=1]) 
'*******************************************************************


'*******************************************************************
' Filter API Specific
'*******************************************************************

GLOBAL glpBits AS LPBYTE
GLOBAL gClone  AS LPBYTE
GLOBAL gH
GLOBAL gW


TYPE IMAGE
  width AS INTEGER
  height AS INTEGER
  bufLen AS INTEGER
  bmi AS BITMAPINFO
  buf AS LPBYTE
END TYPE


'*******************************************************************************************
'         An assortment of 3x3 kernels that I've found scattered across the WWW
'*******************************************************************************************
DIM RAW Filter_01! [] = {.0,.2,.0,.2,.2,.2,.0,.2,.0}                          'Soft Blur
DIM RAW Filter_02! [] = {1,2,1,2,4,2,1,2,1}                                   'Gaussian Blur 1
DIM RAW Filter_03! [] = {0,1,0,1,4,1,0,1,0}                                   'Gaussian Blur 2
DIM RAW Filter_04! [] = {1, 2, 1, 2, 4, 2, 1, 2, 1}                           'Gaussian Blur
DIM RAW Filter_05! [] = {0, 1, 0, 1, 1, 1, 0, 1, 0}                           'Gaussian Blur
DIM RAW Filter_06! [] = {0.11,0.11,0.11,0.11,0.11,0.11,0.11,0.11,0.11}        'Box Blur
DIM RAW Filter_07! [] = {0.062,0.12,0.062,0.12,0.25,0.12,0.062,0.12,0.062}    'Triangle Blur
DIM RAW Filter_08! [] = {1,1,1,1,1,1,1,1,1}                                   'Averaging Blur
DIM RAW Filter_09! [] = {5,3,6,2,1,9,8,4,7}                                   'Mean Filter
DIM RAW Filter_10! [] = {6,2,0,3,97,4,19,3,10}                                'Median Filter


DIM RAW Filter_11! [] = {-1, -1, -1, -1, 9, -1, -1, -1, -1}                   'Sharpen
DIM RAW Filter_12! [] = {0,-1,0,-1,8,-1,0,-1,0}                               'Sharpen
DIM RAW Filter_13! [] = {-1, -1, -1, -1, 12, -1, -1, -1, -1}                  'Sharpen More
DIM RAW Filter_14! [] = {0,-1,0,-1,5,-1,0,-1,-0}                              'Sharpen 1
DIM RAW Filter_15! [] = {1,-2,1,-2,5,-2,1,-2,1}                               'Sharpen 2
DIM RAW Filter_16! [] = {1,1,1,1,-7,1,1,1,1}                                  'Hyper Sharpen

DIM RAW Filter_17! [] = {-1,-1,-1,-1, 9,-1,-1,-1,-1}                          'Mean Removal

DIM RAW Filter_18! [] = {0,0,0,-1,2,-1,0,0,0}                                 'Emboss Horz   Bias 128
DIM RAW Filter_19! [] = {0,-1,0,0,0,0,0,1,0}                                  'Emboss Vert   Bias 128
DIM RAW Filter_20! [] = {-1,-1,-1,-1,8,-1,-1,-1,-1}                           'Emboss Both   Bias 128
DIM RAW Filter_21! [] = {-1,-1,0,-1,0,1,0,1,1}                                'Emboss A  (Gray)
DIM RAW Filter_22! [] = {-2,-1,0,-1,1,1,0,1,2}                                'Emboss B  (Color)

DIM RAW Filter_23! [] = {1,2,1,0,0,0,-1,-2,-1}                                'Sobel Horz
DIM RAW Filter_24! [] = {1,0,-1,2,0,-2,1,0,-1}                                'Sobel Vert

DIM RAW Filter_25! [] = {1,1,1,0,0,0,-1,-1,-1}                                'Prewitt Horz
DIM RAW Filter_26! [] = {1,0,-1,1,0,-1,1,0,-1}                                'Prewitt Vert

DIM RAW Filter_27! [] = {5,5,5,-3,0,-3,-3,-3,-3}                              'Kirsch

DIM RAW Filter_28! [] = {0,1,0,1,-4,1,0,1,0}                                  'Edge Detect A  Bias:128
DIM RAW Filter_29! [] = {1,1,1,0,0,0,-1,-1,-1}                                'Edge Detect B  Bias:128
DIM RAW Filter_30! [] = {0,0,0,-1,1,0,0,0,0}                                  'Edge Enhanc A
DIM RAW Filter_31! [] = {0,-1,0,0,1,0,0,0,0}                                  'Edge Enhanc B


'*******************************************************************************************
'         An assortment of 5x5 kernels that I've found scattered across the WWW
'*******************************************************************************************


SET Filter_Sharpen![]
-1, -1, -1, -1, -1,
-1,  2,  2,  2, -1,
-1,  2,  8,  2, -1,
-1,  2,  2,  2, -1,
-1, -1, -1, -1, -1
END SET



SET Filter_GaussianSharpen![]
-1, -1, -1, -1, -1,
-1,  2,  2,  2, -1,
-1,  2,  9,  2, -1,
-1,  2,  2,  2, -1,
-1, -1, -1, -1, -1
END SET


SET Filter_GaussianBlur![]
1,  4,  7,  4, 1,
4, 16, 26, 16, 4,
7, 26, 41, 26, 7,
4, 16, 26, 16, 4,
1,  4,  7,  4, 1 
END SET


SET Filter_SimpleBlur![]
1, 1, 2, 1, 1,
1, 2, 3, 2, 1,
2, 3, 4, 3, 2,
1, 2, 3, 2, 1,
1, 1, 2, 1, 1
END SET


SET Filter_InvertedBlur![]
3, 3, 2, 3, 3,
3, 2, 1, 2, 3,
2, 1, 0, 1, 2,
3, 2, 1, 2, 3,
3, 3, 2, 3, 3
END SET



SET Filter_Mean![]
.111,.111,.111,.111,.111,
.111,.111,.111,.111,.111,
.111,.111,.111,.111,.111,
.111,.111,.111,.111,.111,
.111,.111,.111,.111,.111
END SET



SET Filter_Motion![]
0, 0, 0, 0, 1,
0, 0, 0, 1, 0,
0, 0, 1, 0, 0,
0, 1, 0, 0, 0,
1, 0, 0, 0, 0
END SET



SET Filter_HorzEdge![]
0,0,0,0,0,
0,0,0,0,0,
-1,-1,2,0,0,
0,0,0,0,0,
0,0,0,0,0
END SET


SET Filter_VertEdge![]
0,  0, -1,  0,  0,
0,  0, -1,  0,  0,
0,  0,  4,  0,  0,
0,  0, -1,  0,  0,
0,  0, -1,  0,  0
END SET


SET Filter_AllEdge![]
-1,  0,  0,  0,  0,
0, -2,  0,  0,  0,
0,  0,  6,  0,  0,
0,  0,  0, -2,  0,
0,  0,  0,  0, -1
END SET


SET Filter_Emboss![]
-1, -1, -1, -1,  0,
-1, -1, -1,  0,  1,
-1, -1,  0,  1,  1,
-1,  0,  1,  1,  1,
0,  1,  1,  1,  1
END SET


SET Filter_Engrave![]
1, 1, 1, 1, 0,
1, 1, 1, 0,-1,
1,-1, 0, 1,-1,
1, 0,-1,-1,-1,
0,-1,-1,-1, 1
END SET





FUNCTION Convolve3x3 OPTIONAL (bmpSource AS HBITMAP, Filter![], Scalar=1, Bias=0) AS HBITMAP
'*****************************************************************************************
'      bmpSource is not modified
'*****************************************************************************************
DIM pbmi     AS PBITMAPINFO
DIM pbih     AS PBITMAPINFOHEADER
DIM hMemDC   AS HDC
DIM hDestDC  AS HDC
DIM hDC      AS HDC
DIM hBmp     AS HBITMAP
DIM bmp      AS BITMAP
DIM cClrBits AS WORD
DIM R,G,B
'***********************************************
gH = BCX_BMPHEIGHT(bmpSource)
gW = BCX_BMPWIDTH (bmpSource)

hMemDC = CreateCompatibleDC(NULL)
SelectObject(hMemDC, bmpSource)
hDestDC = CreateCompatibleDC(hMemDC)
hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
SelectObject(hDestDC,hBmp)
BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

SELECT CASE cClrBits
  CASE     1   : cClrBits =  1
  CASE <=  4   : cClrBits =  4
  CASE <=  8   : cClrBits =  8
  CASE <= 16   : cClrBits = 16
  CASE <= 24   : cClrBits = 24
  CASE ELSE    : cClrBits = 32
END SELECT


IF cClrBits < 24 THEN
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
ELSE
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
END IF

pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
pbmi->bmiHeader.biWidth    = bmp.bmWidth
pbmi->bmiHeader.biHeight   = bmp.bmHeight
pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

IF cClrBits < 24 THEN
  pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
ELSE
  pbmi->bmiHeader.biClrUsed = 0
END IF

pbmi->bmiHeader.biCompression = BI_RGB
pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
pbmi->bmiHeader.biClrImportant = 0

pbih = (PBITMAPINFOHEADER) pbmi
glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

IF NOT glpBits THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

hDC = CreateCompatibleDC (NULL)

IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

'**************************************************************
'                       Start Convolution Filter
'**************************************************************
gClone = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)
GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,gClone, pbmi, DIB_RGB_COLORS)
'**************************************************************

REGISTER x
REGISTER y
REGISTER Sum!

FOR INTEGER i = 0 TO 8
  Sum = Sum + Filter[i]
NEXT

IF Sum <1 THEN Sum = 1

FOR y = 2 TO gH-2
  FOR x = 2 TO gW-2

    B = (Filter[0]*GCB(0,x-1,y-1)) + (Filter[3]*GCB(0,x,y-1)) + (Filter[6]*GCB(0,x+1,y-1)) +  _
    (Filter[1]*GCB(0,x-1,y))   + (Filter[4]*GCB(0,x,y))   + (Filter[7]*GCB(0,x+1,y))   +  _
    (Filter[2]*GCB(0,x-1,y+1)) + (Filter[5]*GCB(0,x,y+1)) + (Filter[8]*GCB(0,x+1,y+1))

    G = (Filter[0]*GCB(1,x-1,y-1)) + (Filter[3]*GCB(1,x,y-1)) + (Filter[6]*GCB(1,x+1,y-1)) +  _
    (Filter[1]*GCB(1,x-1,y))   + (Filter[4]*GCB(1,x,y))   + (Filter[7]*GCB(1,x+1,y))   +  _
    (Filter[2]*GCB(1,x-1,y+1)) + (Filter[5]*GCB(1,x,y+1)) + (Filter[8]*GCB(1,x+1,y+1))

    R = (Filter[0]*GCB(2,x-1,y-1)) + (Filter[3]*GCB(2,x,y-1)) + (Filter[6]*GCB(2,x+1,y-1)) +  _
    (Filter[1]*GCB(2,x-1,y))   + (Filter[4]*GCB(2,x,y))   + (Filter[7]*GCB(2,x+1,y))   +  _
    (Filter[2]*GCB(2,x-1,y+1)) + (Filter[5]*GCB(2,x,y+1)) + (Filter[8]*GCB(2,x+1,y+1))

    R = R / Sum
    G = G / Sum
    B = B / Sum

    R = (R * Scalar) + Bias
    G = (G * Scalar) + Bias
    B = (B * Scalar) + Bias

    R = MIN(MAX(R,0), 255)
    G = MIN(MAX(G,0), 255)
    B = MIN(MAX(B,0), 255)

    SetRedByte  (x, y, R)
    SetGreenByte(x, y, G)
    SetBlueByte (x, y, B)

  NEXT
NEXT

'**************************************************************
SetDIBits (hDC, hBmp, 0,(WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
DeleteDC (hMemDC)
DeleteDC (hDestDC)
DeleteDC (hDC)

GlobalFree ((HGLOBAL) gClone)
GlobalFree ((HGLOBAL) glpBits)
GlobalFree ((HGLOBAL) pbmi)
FUNCTION = hBmp
END FUNCTION







FUNCTION Convolve5x5 OPTIONAL (bmpSource AS HBITMAP, Filter![], Scalar=1, Bias=0) AS HBITMAP
'*****************************************************************************************
'      bmpSource is not modified
'*****************************************************************************************
DIM pbmi     AS PBITMAPINFO
DIM pbih     AS PBITMAPINFOHEADER
DIM hMemDC   AS HDC
DIM hDestDC  AS HDC
DIM hDC      AS HDC
DIM hBmp     AS HBITMAP
DIM bmp      AS BITMAP
DIM cClrBits AS WORD
DIM R,G,B
'***********************************************
gH = BCX_BMPHEIGHT(bmpSource)
gW = BCX_BMPWIDTH (bmpSource)

hMemDC = CreateCompatibleDC(NULL)
SelectObject(hMemDC, bmpSource)
hDestDC = CreateCompatibleDC(hMemDC)
hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
SelectObject(hDestDC,hBmp)
BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

SELECT CASE cClrBits
  CASE     1   : cClrBits =  1
  CASE <=  4   : cClrBits =  4
  CASE <=  8   : cClrBits =  8
  CASE <= 16   : cClrBits = 16
  CASE <= 24   : cClrBits = 24
  CASE ELSE    : cClrBits = 32
END SELECT

IF cClrBits < 24 THEN
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
ELSE
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
END IF

pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
pbmi->bmiHeader.biWidth    = bmp.bmWidth
pbmi->bmiHeader.biHeight   = bmp.bmHeight
pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

IF cClrBits < 24 THEN
  pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
ELSE
  pbmi->bmiHeader.biClrUsed = 0
END IF

pbmi->bmiHeader.biCompression = BI_RGB
pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
pbmi->bmiHeader.biClrImportant = 0

pbih = (PBITMAPINFOHEADER) pbmi
glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

IF NOT glpBits THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

hDC = CreateCompatibleDC (NULL)

IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

'**************************************************************
'                       Start Convolution Filter
'**************************************************************
gClone = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)
GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,gClone, pbmi, DIB_RGB_COLORS)
'**************************************************************


REGISTER x
REGISTER y
REGISTER Sum!

FOR INTEGER i = 0 TO 24
  Sum = Sum + Filter[i]
NEXT

IF Sum <1 THEN Sum = 1

FOR y = 2 TO gH-3
  FOR x = 2 TO gW-3


    B=(Filter[0]*GCB(0,x-2,y-2))+(Filter[5]*GCB(0,x-1,y-2))+(Filter[10]*GCB(0,x,y-2))+(Filter[15]*GCB(0,x+1,y-2))+(Filter[20]*GCB(0,x+2,y-2))+ _
    (Filter[1]*GCB(0,x-2,y-1))+(Filter[6]*GCB(0,x-1,y-1))+(Filter[11]*GCB(0,x,y-1))+(Filter[16]*GCB(0,x+1,y-1))+(Filter[21]*GCB(0,x+2,y-1))+ _
    (Filter[2]*GCB(0,x-2,y))  +(Filter[7]*GCB(0,x-1,y))  +(Filter[12]*GCB(0,x,y))  +(Filter[17]*GCB(0,x+1,y))  +(Filter[22]*GCB(0,x+2,y))  + _
    (Filter[3]*GCB(0,x-2,y+1))+(Filter[8]*GCB(0,x-1,y+1))+(Filter[13]*GCB(0,x,y+1))+(Filter[18]*GCB(0,x+1,y+1))+(Filter[23]*GCB(0,x+2,y+1))+ _
    (Filter[4]*GCB(0,x-2,y+2))+(Filter[9]*GCB(0,x-1,y+2))+(Filter[14]*GCB(0,x,y+2))+(Filter[19]*GCB(0,x+1,y+2))+(Filter[24]*GCB(0,x+2,y+2))

    G=(Filter[0]*GCB(1,x-2,y-2))+(Filter[5]*GCB(1,x-1,y-2))+(Filter[10]*GCB(1,x,y-2))+(Filter[15]*GCB(1,x+1,y-2))+(Filter[20]*GCB(1,x+2,y-2))+ _
    (Filter[1]*GCB(1,x-2,y-1))+(Filter[6]*GCB(1,x-1,y-1))+(Filter[11]*GCB(1,x,y-1))+(Filter[16]*GCB(1,x+1,y-1))+(Filter[21]*GCB(1,x+2,y-1))+ _
    (Filter[2]*GCB(1,x-2,y))  +(Filter[7]*GCB(1,x-1,y))  +(Filter[12]*GCB(1,x,y))  +(Filter[17]*GCB(1,x+1,y))  +(Filter[22]*GCB(1,x+2,y))  + _
    (Filter[3]*GCB(1,x-2,y+1))+(Filter[8]*GCB(1,x-1,y+1))+(Filter[13]*GCB(1,x,y+1))+(Filter[18]*GCB(1,x+1,y+1))+(Filter[23]*GCB(1,x+2,y+1))+ _
    (Filter[4]*GCB(1,x-2,y+2))+(Filter[9]*GCB(1,x-1,y+2))+(Filter[14]*GCB(1,x,y+2))+(Filter[19]*GCB(1,x+1,y+2))+(Filter[24]*GCB(1,x+2,y+2))

    R=(Filter[0]*GCB(2,x-2,y-2))+(Filter[5]*GCB(2,x-1,y-2))+(Filter[10]*GCB(2,x,y-2))+(Filter[15]*GCB(2,x+1,y-2))+(Filter[20]*GCB(2,x+2,y-2))+ _
    (Filter[1]*GCB(2,x-2,y-1))+(Filter[6]*GCB(2,x-1,y-1))+(Filter[11]*GCB(2,x,y-1))+(Filter[16]*GCB(2,x+1,y-1))+(Filter[21]*GCB(2,x+2,y-1))+ _
    (Filter[2]*GCB(2,x-2,y))  +(Filter[7]*GCB(2,x-1,y))  +(Filter[12]*GCB(2,x,y))  +(Filter[17]*GCB(2,x+1,y))  +(Filter[22]*GCB(2,x+2,y))  + _
    (Filter[3]*GCB(2,x-2,y+1))+(Filter[8]*GCB(2,x-1,y+1))+(Filter[13]*GCB(2,x,y+1))+(Filter[18]*GCB(2,x+1,y+1))+(Filter[23]*GCB(2,x+2,y+1))+ _
    (Filter[4]*GCB(2,x-2,y+2))+(Filter[9]*GCB(2,x-1,y+2))+(Filter[14]*GCB(2,x,y+2))+(Filter[19]*GCB(2,x+1,y+2))+(Filter[24]*GCB(2,x+2,y+2))

    R = R / Sum
    G = G / Sum
    B = B / Sum

    R = (R * Scalar) + Bias
    G = (G * Scalar) + Bias
    B = (B * Scalar) + Bias

    R = MIN(MAX(R,0), 255)
    G = MIN(MAX(G,0), 255)
    B = MIN(MAX(B,0), 255)

    SetRedByte  (x, y, R)
    SetGreenByte(x, y, G)
    SetBlueByte (x, y, B)

  NEXT
NEXT

'**************************************************************
SetDIBits (hDC, hBmp, 0,(WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
DeleteDC (hMemDC)
DeleteDC (hDestDC)
DeleteDC (hDC)

GlobalFree ((HGLOBAL) gClone)
GlobalFree ((HGLOBAL) glpBits)
GlobalFree ((HGLOBAL) pbmi)
FUNCTION = hBmp
END FUNCTION







FUNCTION Blend (A1 AS HBITMAP, B1 AS HBITMAP) AS HBITMAP
  DIM RAW A = (HBITMAP)CopyImage(A1,IMAGE_BITMAP,0,0,0)AS HBITMAP
  DIM RAW B = (HBITMAP)CopyImage(B1,IMAGE_BITMAP,0,0,0)AS HBITMAP
  DIM RAW W = BCX_BMPWIDTH (A)
  DIM RAW H = BCX_BMPHEIGHT(A)
  DIM RAW bm     AS HBITMAP
  DIM RAW img1   AS IMAGE
  DIM RAW img2   AS IMAGE
  DIM RAW img3   AS IMAGE
  DIM RAW MemHdc AS HDC

  getImage(A,&img1)
  getImage(B,&img2)

  img3.bufLen = W * H * 4
  img3.width = W
  img3.height = H
  img3.buf = calloc(img3.bufLen,1)

  WITH img3.bmi.bmiHeader
  .biBitCount = 32
  .biCompression = BI_RGB
  .biPlanes = 1
  .biSize = SIZEOF(BITMAPINFO)
  .biWidth = W
  .biHeight = H
END WITH

memcpy((void*)img3.buf, (void*)img1.buf, (size_t)img1.bufLen)

FOR INTEGER i = 0 TO img1.bufLen
  IF img2.buf[i] <= img3.buf[i] THEN img3.buf[i] = img2.buf[i]
NEXT

MemHdc = CreateCompatibleDC(NULL)
bm = CreateDIBSection(MemHdc,&img3.bmi,DIB_RGB_COLORS,NULL,0,0)
SetDIBits(MemHdc, bm, 0, (WORD) img3.height, img3.buf, &img3.bmi, DIB_RGB_COLORS)
DeleteDC(MemHdc)

FREE(&img1.buf)
FREE(&img2.buf)
FREE(&img3.buf)

FUNCTION = bm
END FUNCTION




SUB getImage(pic AS HBITMAP, img AS IMAGE PTR)
  LOCAL hDC AS HDC
  LOCAL bm AS BITMAP
  GetObject(pic, SIZEOF(BITMAP), &bm)
  WITH img->bmi.bmiHeader
  .biBitCount = 32
  .biCompression = BI_RGB
  .biPlanes = 1
  .biSize = SIZEOF(BITMAPINFO)
  .biWidth = bm.bmWidth
  .biHeight = bm.bmHeight
END WITH
img->width = bm.bmWidth
img->height = bm.bmHeight
img->bufLen = bm.bmWidth*bm.bmHeight*4
img->buf = calloc(img->bufLen,1);
hDC = CreateCompatibleDC(0)
SelectObject(hDC, pic)
GetDIBits(hDC, pic, 0, img->height, img->buf, &img->bmi,DIB_RGB_COLORS)
DeleteObject(pic)
DeleteDC(hDC)
END SUB






FUNCTION AntiAlias (SrcBmp AS HBITMAP) AS HBITMAP
  DIM hBmp AS HBITMAP
  hBmp = ReSizeBmp(SrcBmp,BCX_BMPWIDTH(SrcBmp)*2,BCX_BMPHEIGHT(SrcBmp)*2)
  hBmp = Soften (hBmp)
  hBmp = ReSizeBmp(hBmp,BCX_BMPWIDTH(SrcBmp),BCX_BMPHEIGHT(SrcBmp))
  FUNCTION = hBmp
END FUNCTION





FUNCTION ReSizeBmp (SrcBmp AS HBITMAP, W, H) AS HBITMAP
'**********************************************************
' If you leave one of the desired dimensions zero it will
' scale the image while preserving the aspect ratio. Also,
' the scaled image is much cleaner looking.
'**********************************************************
  DIM RAW bm AS BITMAP

  IF NOT SrcBmp THEN FUNCTION = 0
  GetObject(SrcBmp, SIZEOF(bm), &bm)

  IF NOT H THEN
    H = W *((float)bm.bmHeight/bm.bmWidth)
  ELSEIF NOT W THEN
    W = H *((float)bm.bmWidth/bm.bmHeight)
  END IF

  FUNCTION = (HBITMAP)CopyImage(SrcBmp,IMAGE_BITMAP,W,H,0)
END FUNCTION



FUNCTION GRB (x,y)            'Get Red Byte
  REGISTER pPixel AS LPBYTE
  pPixel = glpBits
  pPixel = pPixel + (y * gW * 4) + (x * 4)
  FUNCTION =  pPixel[2]
END FUNCTION


FUNCTION GGB (x,y)            'Get Green Byte
  REGISTER pPixel AS LPBYTE
  pPixel = glpBits
  pPixel = pPixel + (y * gW * 4) + (x * 4)
  FUNCTION =  pPixel[1]
END FUNCTION



FUNCTION GBB (x,y)            'Get Blue Byte
  REGISTER pPixel AS LPBYTE
  pPixel = glpBits
  pPixel = pPixel + (y * gW * 4) + (x * 4)
  FUNCTION =  pPixel[0]
END FUNCTION



FUNCTION GCB (i,x,y)            ' Get_gClone_Byte i = 0,1,2=R,G,B
REGISTER pPixel AS LPBYTE
pPixel = gClone
pPixel = pPixel + (y * gW * 4) + (x * 4)
FUNCTION =  pPixel[i]
END FUNCTION



SUB SetAnyByte (i,x,y,Value)    ' SetAnyByte i = 0,1,2=R,G,B
  REGISTER pPixel AS LPBYTE
  pPixel = glpBits
  pPixel = pPixel + (y * gW * 4) + (x * 4)
  pPixel[i] = Value
END SUB


SUB SetRedByte (x,y,Value)
  REGISTER pPixel AS LPBYTE
  pPixel = glpBits
  pPixel = pPixel + (y * gW * 4) + (x * 4)
  pPixel[2] = Value
END SUB



SUB SetGreenByte (x,y,Value)
  REGISTER pPixel AS LPBYTE
  pPixel = glpBits
  pPixel = pPixel + (y * gW * 4) + (x * 4)
  pPixel[1] = Value
END SUB



SUB SetBlueByte (x,y,Value)
  REGISTER pPixel AS LPBYTE
  pPixel = glpBits
  pPixel = pPixel + (y * gW * 4) + (x * 4)
  pPixel[0] = Value
END SUB




FUNCTION Negative (bmpSource AS HBITMAP) AS HBITMAP
'**************************************************
'      bmpSource is not modified
'**************************************************
  DIM pbmi     AS PBITMAPINFO
  DIM pbih     AS PBITMAPINFOHEADER
  DIM hMemDC   AS HDC
  DIM hDestDC  AS HDC
  DIM hDC      AS HDC
  DIM hBmp     AS HBITMAP
  DIM bmp      AS BITMAP
  DIM cClrBits AS WORD

'***********************************************
  gH = BCX_BMPHEIGHT(bmpSource)
  gW = BCX_BMPWIDTH (bmpSource)

  hMemDC = CreateCompatibleDC(NULL)
  SelectObject(hMemDC, bmpSource)
  hDestDC = CreateCompatibleDC(hMemDC)
  hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
  SelectObject(hDestDC,hBmp)
  BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

  IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

  SELECT CASE cClrBits
    CASE     1   : cClrBits =  1
    CASE <=  4   : cClrBits =  4
    CASE <=  8   : cClrBits =  8
    CASE <= 16   : cClrBits = 16
    CASE <= 24   : cClrBits = 24
    CASE ELSE    : cClrBits = 32
  END SELECT

  IF cClrBits < 24 THEN
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
  ELSE
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
  END IF

  pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
  pbmi->bmiHeader.biWidth    = bmp.bmWidth
  pbmi->bmiHeader.biHeight   = bmp.bmHeight
  pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
  pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

  IF cClrBits < 24 THEN
    pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
  ELSE
    pbmi->bmiHeader.biClrUsed = 0
  END IF

  pbmi->bmiHeader.biCompression = BI_RGB
  pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
  pbmi->bmiHeader.biClrImportant = 0

  pbih = (PBITMAPINFOHEADER) pbmi
  glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

  IF NOT glpBits THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  hDC = CreateCompatibleDC (NULL)

  IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF
'**************************************************************
'                         Negative Filter
'**************************************************************
  REGISTER x
  REGISTER y

  FOR y = 1 TO gH-1
    FOR x = 1 TO gW-1
      SetRedByte   (x,y,255-GRB(x,y))
      SetGreenByte (x,y,255-GGB(x,y))
      SetBlueByte  (x,y,255-GBB(x,y))
    NEXT
  NEXT
'**************************************************************
'                       End Negative Filter
'**************************************************************
  SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
  DeleteDC (hMemDC)
  DeleteDC (hDestDC)
  DeleteDC (hDC)
  GlobalFree ((HGLOBAL) glpBits)
  GlobalFree ((HGLOBAL) pbmi)
  FUNCTION = hBmp
END FUNCTION







FUNCTION Sharpen (bmpSource AS HBITMAP) AS HBITMAP
'**************************************************
'      bmpSource is not modified
'**************************************************
  DIM pbmi   AS PBITMAPINFO
  DIM pbih     AS PBITMAPINFOHEADER
  DIM hMemDC   AS HDC
  DIM hDestDC  AS HDC
  DIM hDC      AS HDC
  DIM hBmp     AS HBITMAP
  DIM bmp      AS BITMAP
  DIM cClrBits AS WORD
  DIM R,G,B
'***********************************************
  gH = BCX_BMPHEIGHT(bmpSource)
  gW = BCX_BMPWIDTH (bmpSource)

  hMemDC = CreateCompatibleDC(NULL)
  SelectObject(hMemDC, bmpSource)
  hDestDC = CreateCompatibleDC(hMemDC)
  hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
  SelectObject(hDestDC,hBmp)
  BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

  IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

  SELECT CASE cClrBits
    CASE     1   : cClrBits =  1
    CASE <=  4   : cClrBits =  4
    CASE <=  8   : cClrBits =  8
    CASE <= 16   : cClrBits = 16
    CASE <= 24   : cClrBits = 24
    CASE ELSE    : cClrBits = 32
  END SELECT

  IF cClrBits < 24 THEN
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
  ELSE
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
  END IF

  pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
  pbmi->bmiHeader.biWidth    = bmp.bmWidth
  pbmi->bmiHeader.biHeight   = bmp.bmHeight
  pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
  pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

  IF cClrBits < 24 THEN
    pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
  ELSE
    pbmi->bmiHeader.biClrUsed = 0
  END IF

  pbmi->bmiHeader.biCompression = BI_RGB
  pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
  pbmi->bmiHeader.biClrImportant = 0

  pbih = (PBITMAPINFOHEADER) pbmi
  glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

  IF NOT glpBits THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  hDC = CreateCompatibleDC (NULL)

  IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

'**************************************************************
'                       Start sharpen Filter
'**************************************************************
  DIM RAW mf = 27
  DIM RAW dF =  9

  REGISTER x
  REGISTER y

  FOR y = 1 TO gH - 1
    FOR x = 1 TO gW - 1

      R = _
      GRB(x, y-1) + GRB(x-1, y) + GRB(x+1, y) + GRB(x, y+1) + _
      GRB(x+1, y+1) + GRB(x-1, y+1) + GRB(x+1, y-1) + GRB(x-1, y-1)
      R = ((mf * GRB(x, y) - 2 * R) / dF)

      G = _
      GGB(x, y-1)+ GGB(x-1, y) + GGB( x+1, y) + GGB( x, y+1) + _
      GGB( x+1, y+1) + GGB( x-1, y+1) + GGB( x+1, y-1) + GGB( x-1, y-1)
      G = ((mf * GGB(x, y) - 2 * G) / dF)

      B = _
      GBB(x, y-1)+ GBB(x-1, y) + GBB(x+1, y) + GBB(x, y+1) + _
      GBB(x+1, y+1) + GBB(x-1, y+1) + GBB(x+1, y-1) + GBB(x-1, y-1)
      B = ((mf * GBB(x, y) - 2 * B) / dF)

      R = MIN(MAX(R, 0), 255)
      G = MIN(MAX(G, 0), 255)
      B = MIN(MAX(B, 0), 255)

      SetRedByte   (x, y, R)
      SetGreenByte (x, y, G)
      SetBlueByte  (x, y, B)
    NEXT
  NEXT
'**************************************************************
'                       End Sharpen Filter
'**************************************************************
  SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
  DeleteDC (hMemDC)
  DeleteDC (hDestDC)
  DeleteDC (hDC)
  GlobalFree ((HGLOBAL) glpBits)
  GlobalFree ((HGLOBAL) pbmi)
  FUNCTION = hBmp
END FUNCTION







FUNCTION Soften (bmpSource AS HBITMAP) AS HBITMAP
'**************************************************
'      bmpSource is not modified
'**************************************************
  DIM pbmi   AS PBITMAPINFO
  DIM pbih     AS PBITMAPINFOHEADER
  DIM hMemDC   AS HDC
  DIM hDestDC  AS HDC
  DIM hDC      AS HDC
  DIM hBmp     AS HBITMAP
  DIM bmp      AS BITMAP
  DIM cClrBits AS WORD
  DIM R,G,B
'***********************************************
  gH = BCX_BMPHEIGHT(bmpSource)
  gW = BCX_BMPWIDTH (bmpSource)

  hMemDC = CreateCompatibleDC(NULL)
  SelectObject(hMemDC, bmpSource)
  hDestDC = CreateCompatibleDC(hMemDC)
  hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
  SelectObject(hDestDC,hBmp)
  BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

  IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

  SELECT CASE cClrBits
    CASE     1   : cClrBits =  1
    CASE <=  4   : cClrBits =  4
    CASE <=  8   : cClrBits =  8
    CASE <= 16   : cClrBits = 16
    CASE <= 24   : cClrBits = 24
    CASE ELSE    : cClrBits = 32
  END SELECT

  IF cClrBits < 24 THEN
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
  ELSE
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
  END IF

  pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
  pbmi->bmiHeader.biWidth    = bmp.bmWidth
  pbmi->bmiHeader.biHeight   = bmp.bmHeight
  pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
  pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

  IF cClrBits < 24 THEN
    pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
  ELSE
    pbmi->bmiHeader.biClrUsed = 0
  END IF

  pbmi->bmiHeader.biCompression = BI_RGB
  pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
  pbmi->bmiHeader.biClrImportant = 0

  pbih = (PBITMAPINFOHEADER) pbmi
  glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

  IF NOT glpBits THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  hDC = CreateCompatibleDC (NULL)

  IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

'**************************************************************
'                       Start Soften Filter
'**************************************************************
  REGISTER x
  REGISTER y

  FOR y = 1 TO gH - 1
    FOR x = 1 TO gW - 1

      R = (GRB(x-1,y) + GRB(x,y) + GRB(x+1,y))/3
      G = (GGB(x-1,y) + GGB(x,y) + GGB(x+1,y))/3
      B = (GBB(x-1,y) + GBB(x,y) + GBB(x+1,y))/3

      R = MIN(MAX(R, 0), 255)
      G = MIN(MAX(G, 0), 255)
      B = MIN(MAX(B, 0), 255)

      SetRedByte   (x, y, R)
      SetGreenByte (x, y, G)
      SetBlueByte  (x, y, B)

    NEXT
  NEXT

'**************************************************************
'                       End Soften Filter
'**************************************************************

  SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
  DeleteDC (hMemDC)
  DeleteDC (hDestDC)
  DeleteDC (hDC)
  GlobalFree ((HGLOBAL) glpBits)
  GlobalFree ((HGLOBAL) pbmi)
  FUNCTION = hBmp
END FUNCTION





FUNCTION Contrast OPTIONAL (bmpSource AS HBITMAP, Factor = 10) AS HBITMAP
'**************************************************
'      bmpSource is not modified
'**************************************************
DIM pbmi   AS PBITMAPINFO
DIM pbih     AS PBITMAPINFOHEADER
DIM hMemDC   AS HDC
DIM hDestDC  AS HDC
DIM hDC      AS HDC
DIM hBmp     AS HBITMAP
DIM bmp      AS BITMAP
DIM cClrBits AS WORD
DIM R,G,B
'***********************************************
gH = BCX_BMPHEIGHT(bmpSource)
gW = BCX_BMPWIDTH (bmpSource)

hMemDC = CreateCompatibleDC(NULL)
SelectObject(hMemDC, bmpSource)
hDestDC = CreateCompatibleDC(hMemDC)
hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
SelectObject(hDestDC,hBmp)
BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

SELECT CASE cClrBits
  CASE     1   : cClrBits =  1
  CASE <=  4   : cClrBits =  4
  CASE <=  8   : cClrBits =  8
  CASE <= 16   : cClrBits = 16
  CASE <= 24   : cClrBits = 24
  CASE ELSE    : cClrBits = 32
END SELECT

IF cClrBits < 24 THEN
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
ELSE
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
END IF

pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
pbmi->bmiHeader.biWidth    = bmp.bmWidth
pbmi->bmiHeader.biHeight   = bmp.bmHeight
pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

IF cClrBits < 24 THEN
  pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
ELSE
  pbmi->bmiHeader.biClrUsed = 0
END IF

pbmi->bmiHeader.biCompression = BI_RGB
pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
pbmi->bmiHeader.biClrImportant = 0

pbih = (PBITMAPINFOHEADER) pbmi
glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

IF NOT glpBits THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

hDC = CreateCompatibleDC (NULL)

IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

'**************************************************************
'                       Start Contrast Filter
'**************************************************************

DIM Speed [766]

DIM sF AS Single
DIM mCol, nCol

REGISTER x
REGISTER y

FOR  x = 0 TO 765
  Speed[x] = x *0.33
NEXT

mCol = 0
nCol = 0

FOR y = 1 TO gH-1
  FOR x = 1 TO gW-1
    B = GBB(x,y)
    G = GGB(x,y)
    R = GRB(x,y)
    mCol = mCol + Speed[R + G + B]
    nCol = nCol + 1
  NEXT
NEXT

mCol = mCol / nCol
sF = (Factor + 100.0) *0.01

FOR x = 0 TO 255
  Speed[x] = (x - mCol) * sF + mCol
NEXT

FOR y = 1 TO gH -1
  FOR x = 1 TO gW -1

    B = Speed[GBB(x,y)]
    G = Speed[GGB(x,y)]
    R = Speed[GRB(x,y)]

    R = MIN(MAX(R, 0), 255)
    G = MIN(MAX(G, 0), 255)
    B = MIN(MAX(B, 0), 255)

    WHILE (B < 0) OR (B > 255) OR (G < 0) OR (G > 255) OR (R < 0) OR (R > 255)
      IF (B <= 0) AND (G <= 0) AND (R <= 0) THEN
        B = 0
        G = 0
        R = 0
      END IF
      IF (B >= 255) AND (G >= 255) AND (R >= 255) THEN
        B = 255
        G = 255
        R = 255
      END IF
      IF B < 0 THEN
        G = (G + B) / 2
        R = (R + B) / 2
        B = 0
      END IF
      IF B > 255 THEN
        G = G + (B - 255) / 2
        R = R + (B - 255) / 2
        B = 255
      END IF
      IF G < 0 THEN
        B = (B + G) / 2
        R = (R + G) / 2
        G = 0
      END IF
      IF G > 255 THEN
        B = B + (G - 255) / 2
        R = R + (G - 255) / 2
        G = 255
      END IF
      IF R < 0 THEN
        G = (G + R) / 2
        B = (B + R) / 2
        R = 0
      END IF
      IF R > 255 THEN
        G = G + (R - 255) / 2
        B = B + (R - 255) / 2
        R = 255
      END IF
    LOOP

    SetRedByte   (x, y, R)
    SetGreenByte (x, y, G)
    SetBlueByte  (x, y, B)
  NEXT
NEXT

'**************************************************************
'                       End Contrast Filter
'**************************************************************
SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
DeleteDC (hMemDC)
DeleteDC (hDestDC)
DeleteDC (hDC)
GlobalFree ((HGLOBAL) glpBits)
GlobalFree ((HGLOBAL) pbmi)
FUNCTION = hBmp
END FUNCTION









FUNCTION Brightness OPTIONAL (bmpSource AS HBITMAP, Factor = 10) AS HBITMAP
'**************************************************
'      bmpSource is not modified
'**************************************************
DIM pbmi   AS PBITMAPINFO
DIM pbih     AS PBITMAPINFOHEADER
DIM hMemDC   AS HDC
DIM hDestDC  AS HDC
DIM hDC      AS HDC
DIM hBmp     AS HBITMAP
DIM bmp      AS BITMAP
DIM cClrBits AS WORD
DIM R,G,B
'***********************************************
gH = BCX_BMPHEIGHT(bmpSource)
gW = BCX_BMPWIDTH (bmpSource)

hMemDC = CreateCompatibleDC(NULL)
SelectObject(hMemDC, bmpSource)
hDestDC = CreateCompatibleDC(hMemDC)
hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
SelectObject(hDestDC,hBmp)
BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

SELECT CASE cClrBits
  CASE     1   : cClrBits =  1
  CASE <=  4   : cClrBits =  4
  CASE <=  8   : cClrBits =  8
  CASE <= 16   : cClrBits = 16
  CASE <= 24   : cClrBits = 24
  CASE ELSE    : cClrBits = 32
END SELECT

IF cClrBits < 24 THEN
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
ELSE
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
END IF

pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
pbmi->bmiHeader.biWidth    = bmp.bmWidth
pbmi->bmiHeader.biHeight   = bmp.bmHeight
pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

IF cClrBits < 24 THEN
  pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
ELSE
  pbmi->bmiHeader.biClrUsed = 0
END IF

pbmi->bmiHeader.biCompression = BI_RGB
pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
pbmi->bmiHeader.biClrImportant = 0

pbih = (PBITMAPINFOHEADER) pbmi
glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

IF NOT glpBits THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

hDC = CreateCompatibleDC (NULL)

IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

'**************************************************************
'                       Start Brightness Filter
'**************************************************************

DIM sF AS Single
DIM Speed![256]

REGISTER x
REGISTER y

sF = (Factor + 100.0) *0.01

FOR x = 0 TO 255
  Speed[x] = x * sF
  IF Speed[x] > 255 THEN Speed[x] = 255
  IF Speed[x] < 0 THEN Speed[x] = 0
NEXT x

FOR y = 1 TO gH
  FOR x = 1 TO gW
    SetRedByte   (x, y, Speed[GRB(x,y)])
    SetGreenByte (x, y, Speed[GGB(x,y)])
    SetBlueByte  (x, y, Speed[GBB(x,y)])
  NEXT
NEXT

'**************************************************************
'                       End Brighness Filter
'**************************************************************
SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
DeleteDC (hMemDC)
DeleteDC (hDestDC)
DeleteDC (hDC)

GlobalFree ((HGLOBAL) glpBits)
GlobalFree ((HGLOBAL) pbmi)
FUNCTION = hBmp
END FUNCTION




'****************************************************
FUNCTION DropShadow (bmpSource AS HBITMAP) AS HBITMAP
'*****************************************************
  DIM RAW hMemDC AS HDC
  DIM RAW hDestDC AS HDC
  DIM RAW bmpNew AS HBITMAP

  DIM RAW H = BCX_BMPHEIGHT(bmpSource)
  DIM RAW W = BCX_BMPWIDTH(bmpSource)

  hMemDC = CreateCompatibleDC(NULL)
  SelectObject(hMemDC, bmpSource)
  hDestDC = CreateCompatibleDC(hMemDC)
  bmpNew  = CreateCompatibleBitmap(hMemDC,W+10,H+10)   ' Increase the size of the bitmap
  SelectObject(hDestDC,bmpNew)
  BitBlt (hDestDC,0,0,W,H,hMemDC,0,0,SRCCOPY)

' Draw the right side of the shadow - Start with painting the offset white

  FOR INTEGER x = W TO W + 10
    FOR INTEGER y = 0 TO 10
      SetPixel(hDestDC, x,  y, RGB(255,255,255))
    NEXT
  NEXT

' Now move on to painting the RIGHT gradient

  FOR INTEGER y = 10 TO H + 10
    SetPixel(hDestDC, W,    y, RGB(90,90,90))
    SetPixel(hDestDC, W+1,  y, RGB(100,100,100))
    SetPixel(hDestDC, W+2,  y, RGB(120,120,120))
    SetPixel(hDestDC, W+3,  y, RGB(145,145,145))
    SetPixel(hDestDC, W+4,  y, RGB(165,165,165))
    SetPixel(hDestDC, W+5,  y, RGB(180,180,180))
    SetPixel(hDestDC, W+6,  y, RGB(205,205,205))
    SetPixel(hDestDC, W+7,  y, RGB(215,215,215))
    SetPixel(hDestDC, W+8,  y, RGB(225,225,225))
    SetPixel(hDestDC, W+9,  y, RGB(247,247,247))
    SetPixel(hDestDC, W+10, y, RGB(255,255,255))
  NEXT

  W = W + 10
  H = H + 10

'Draw the bottom of the shadow - Start with painting the offset white

  FOR INTEGER y = H - 10 TO H
    FOR INTEGER x = 0 TO 10
      SetPixel(hDestDC, x,  y, RGB(255,255,255))
    NEXT
  NEXT

' Now move on to painting the BOTTOM gradient

  FOR INTEGER x = 10 TO W - 10
    SetPixel(hDestDC, x,  H-10,    RGB(95,95,95))
    SetPixel(hDestDC, x,  H-10+1,  RGB(105,105,105))
    SetPixel(hDestDC, x,  H-10+2,  RGB(125,125,125))
    SetPixel(hDestDC, x,  H-10+3,  RGB(150,150,150))
    SetPixel(hDestDC, x,  H-10+4,  RGB(160,160,160))
    SetPixel(hDestDC, x,  H-10+5,  RGB(185,185,185))
    SetPixel(hDestDC, x,  H-10+6,  RGB(200,200,200))
    SetPixel(hDestDC, x,  H-10+7,  RGB(210,210,210))
    SetPixel(hDestDC, x,  H-10+8,  RGB(225,225,225))
    SetPixel(hDestDC, x,  H-10+9,  RGB(246,246,246))
    SetPixel(hDestDC, x,  H-10+10, RGB(255,255,255))
  NEXT

' Now let's Miter The Corner

  FOR INTEGER i = 0 TO 10
    SetPixel(hDestDC, W-10-i, H-10, RGB(90,90,90))
    SetPixel(hDestDC, W-9-i,  H-9,  RGB(100,100,100))
    SetPixel(hDestDC, W-8-i,  H-8,  RGB(120,120,120))
    SetPixel(hDestDC, W-7-i,  H-7,  RGB(140,140,140))
    SetPixel(hDestDC, W-6-i,  H-6,  RGB(160,160,160))
    SetPixel(hDestDC, W-5-i,  H-5,  RGB(180,180,180))
    SetPixel(hDestDC, W-4-i,  H-4,  RGB(200,200,200))
    SetPixel(hDestDC, W-3-i,  H-3,  RGB(214,214,214))
    SetPixel(hDestDC, W-2-i,  H-2,  RGB(218,218,218))
    SetPixel(hDestDC, W-1-i,  H-1,  RGB(247,247,247))
    SetPixel(hDestDC, W,      H,    RGB(255,255,255))
  NEXT

  DeleteDC (hMemDC)
  DeleteDC (hDestDC)
  FUNCTION = SmoothShadow(bmpNew)
END FUNCTION




'**************************************************
FUNCTION SmoothShadow (bmpSource AS HBITMAP) AS HBITMAP
'**************************************************
' This is a local function used by DROPSHADOW
'**************************************************
  DIM RAW hMemDC   AS HDC
  DIM RAW hDestDC  AS HDC
  DIM RAW hBmp     AS HBITMAP
  DIM RAW bmp      AS BITMAP
  DIM RAW pbmi     AS PBITMAPINFO
  DIM RAW hDC      AS HDC
  DIM RAW cClrBits AS WORD
  DIM RAW pbih     AS PBITMAPINFOHEADER
  gH =      BCX_BMPHEIGHT(bmpSource)
  gW =      BCX_BMPWIDTH(bmpSource)
'***********************************************
  hMemDC = CreateCompatibleDC(NULL)
  SelectObject(hMemDC, bmpSource)
  hDestDC = CreateCompatibleDC(hMemDC)
  hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
  SelectObject(hDestDC,hBmp)
  BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************
  IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN FUNCTION = NULL

  cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

  SELECT CASE cClrBits
    CASE     1   : cClrBits =  1
    CASE <=  4   : cClrBits =  4
    CASE <=  8   : cClrBits =  8
    CASE <= 16   : cClrBits = 16
    CASE <= 24   : cClrBits = 24
    CASE ELSE    : cClrBits = 32
  END SELECT

  IF cClrBits < 24 THEN
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
  ELSE
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
  END IF

  pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
  pbmi->bmiHeader.biWidth    = bmp.bmWidth
  pbmi->bmiHeader.biHeight   = bmp.bmHeight
  pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
  pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

  IF cClrBits < 24 THEN
    pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
  ELSE
    pbmi->bmiHeader.biClrUsed = 0
  END IF

  pbmi->bmiHeader.biCompression = BI_RGB
  pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
  pbmi->bmiHeader.biClrImportant = 0

  pbih = (PBITMAPINFOHEADER) pbmi
  glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

  IF NOT glpBits THEN FUNCTION = FALSE

  hDC = CreateCompatibleDC (NULL)

  IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN FUNCTION = NULL

'**************************************************************
'                         Smoothing routine
'**************************************************************
  DIM R,G,B

  FOR INTEGER i = 1 TO 5
    FOR INTEGER y = 1 TO gH-5
      FOR INTEGER x = gW-10 TO gW-2
        R = (GRB(x-1,y) + GRB(x,y) + GRB(x+1,y))*0.333
        G = (GGB(x-1,y) + GGB(x,y) + GGB(x+1,y))*0.333
        B = (GBB(x-1,y) + GBB(x,y) + GBB(x+1,y))*0.333

        R = MIN(MAX(R, 0), 255)
        G = MIN(MAX(G, 0), 255)
        B = MIN(MAX(B, 0), 255)

        SetRedByte   (x, y, R)
        SetGreenByte (x, y, G)
        SetBlueByte  (x, y, B)
      NEXT
    NEXT

    FOR INTEGER y = 9 TO 1 STEP -1
      FOR INTEGER x = gW-3 TO 4 STEP -1

        R = (GRB(x-1,y) + GRB(x,y) + GRB(x+1,y))* 0.333
        G = (GGB(x-1,y) + GGB(x,y) + GGB(x+1,y))* 0.333
        B = (GBB(x-1,y) + GBB(x,y) + GBB(x+1,y))* 0.333

        R = MIN(MAX(R, 0), 255)
        G = MIN(MAX(G, 0), 255)
        B = MIN(MAX(B, 0), 255)

        SetRedByte   (x, y, R)
        SetGreenByte (x, y, G)
        SetBlueByte  (x, y, B)

      NEXT
    NEXT
  NEXT

'*****************************************************************************
  SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)

  DeleteDC (hMemDC)
  DeleteDC (hDestDC)
  DeleteDC (hDC)
  GlobalFree ((HGLOBAL) glpBits)
  GlobalFree ((HGLOBAL) pbmi)
  FUNCTION = hBmp
END FUNCTION







'**************************************************
FUNCTION GrayScale (bmpSource AS HBITMAP) AS HBITMAP
'**************************************************
'      bmpSource is not modified
'**************************************************
  DIM RAW hMemDC   AS HDC
  DIM RAW hDestDC  AS HDC
  DIM RAW hBmp     AS HBITMAP
  DIM RAW bmp      AS BITMAP
  DIM RAW pbmi     AS PBITMAPINFO
  DIM RAW hDC      AS HDC
  DIM RAW cClrBits AS WORD
  DIM RAW pbih     AS PBITMAPINFOHEADER
  gH =      BCX_BMPHEIGHT(bmpSource)
  gW =      BCX_BMPWIDTH(bmpSource)
'***********************************************
  hMemDC = CreateCompatibleDC(NULL)
  SelectObject(hMemDC, bmpSource)
  hDestDC = CreateCompatibleDC(hMemDC)
  hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
  SelectObject(hDestDC,hBmp)
  BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************
  IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN FUNCTION = NULL

  cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

  SELECT CASE cClrBits
    CASE     1   : cClrBits =  1
    CASE <=  4   : cClrBits =  4
    CASE <=  8   : cClrBits =  8
    CASE <= 16   : cClrBits = 16
    CASE <= 24   : cClrBits = 24
    CASE ELSE    : cClrBits = 32
  END SELECT

  IF cClrBits < 24 THEN
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
  ELSE
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
  END IF

  pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
  pbmi->bmiHeader.biWidth    = bmp.bmWidth
  pbmi->bmiHeader.biHeight   = bmp.bmHeight
  pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
  pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

  IF cClrBits < 24 THEN
    pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
  ELSE
    pbmi->bmiHeader.biClrUsed = 0
  END IF

  pbmi->bmiHeader.biCompression = BI_RGB
  pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
  pbmi->bmiHeader.biClrImportant = 0

  pbih = (PBITMAPINFOHEADER) pbmi
  glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

  IF NOT glpBits THEN FUNCTION = FALSE

  hDC = CreateCompatibleDC (NULL)

  IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN FUNCTION = NULL

'*****************************************************************************
'              This is where we get to finally manipulate the PIXELS!
'*****************************************************************************
  DIM r,g,b,gray

  FOR INTEGER i = 0 TO pbih->biSizeImage STEP 4
    b = glpBits[i]
    g = glpBits[i+1]
    r = glpBits[i+2]

    gray = 0.3*r + 0.6*g + 0.1*b   'formula for luminance

    glpBits[i]   = gray
    glpBits[i+1] = gray
    glpBits[i+2] = gray
    glpBits[i+3] = 0
  NEXT

'********************************************************************
  SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)

  DeleteDC (hMemDC)
  DeleteDC (hDestDC)
  DeleteDC (hDC)
  GlobalFree ((HGLOBAL) glpBits)
  GlobalFree ((HGLOBAL) pbmi)
  FUNCTION = hBmp
END FUNCTION






'***********************************************************
FUNCTION OutlineShadow (bmpSource AS HBITMAP) AS HBITMAP
'***********************************************************
'      bmpSource is not modified
'***********************************************************
  DIM RAW hMemDC   AS HDC
  DIM RAW hDestDC  AS HDC
  DIM RAW hBmp     AS HBITMAP
  DIM RAW bmp      AS BITMAP
  DIM RAW pbmi     AS PBITMAPINFO
  DIM RAW hDC      AS HDC
  DIM RAW cClrBits AS WORD
  DIM RAW pbih     AS PBITMAPINFOHEADER
  gH = BCX_BMPHEIGHT(bmpSource)
  gW = BCX_BMPWIDTH(bmpSource)
'***********************************************
  hMemDC = CreateCompatibleDC(NULL)
  SelectObject(hMemDC, bmpSource)
  hDestDC = CreateCompatibleDC(hMemDC)
  hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
  SelectObject(hDestDC,hBmp)
  BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************
  IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN FUNCTION = NULL

  cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

  SELECT CASE cClrBits
    CASE     1   : cClrBits =  1
    CASE <=  4   : cClrBits =  4
    CASE <=  8   : cClrBits =  8
    CASE <= 16   : cClrBits = 16
    CASE <= 24   : cClrBits = 24
    CASE ELSE    : cClrBits = 32
  END SELECT

  IF cClrBits < 24 THEN
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
  ELSE
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
  END IF

  pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
  pbmi->bmiHeader.biWidth    = bmp.bmWidth
  pbmi->bmiHeader.biHeight   = bmp.bmHeight
  pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
  pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

  IF cClrBits < 24 THEN
    pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
  ELSE
    pbmi->bmiHeader.biClrUsed = 0
  END IF

  pbmi->bmiHeader.biCompression = BI_RGB
  pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
  pbmi->bmiHeader.biClrImportant = 0

  pbih = (PBITMAPINFOHEADER) pbmi
  glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

  IF NOT glpBits THEN FUNCTION = FALSE

  hDC = CreateCompatibleDC (NULL)

  IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN FUNCTION = NULL

'*****************************************************************************
'     This is where we get to finally manipulate the PIXELS!
'*****************************************************************************

  DIM r1,g1,b1
  DIM r2,g2,b2
  DIM r3,g3,b3

  REGISTER x
  REGISTER y

  FOR y = 1 TO gH - 2
    FOR x = gW - 2 TO 1 STEP -1

      r1 = GRB(x,y)
      g1 = GGB(x,y)
      b1 = GBB (x,y)

      r2 = GRB (x+1,y)
      g2 = GGB (x+1,y)
      b2 = GBB (x+1,y)

      IF (r1+g1+b1<525) AND (r2+g2+b2>525) THEN   '<<<--- NOTE:  3 x 255 = 765
        FOR INTEGER i = 12 TO 0 STEP -1
          r2 = GRB(x+i,y)
          g2 = GGB(x+i,y)
          b2 = GBB(x+i,y)

          IF r2+g2+b2>525 THEN
            SetRedByte   (x+i,y,1+(i*2)*10)
            SetGreenByte (x+i,y,3+(i*2)*10)
            SetBlueByte  (x+i,y,5+(i*2)*10)
          END IF
        NEXT
      END IF
    NEXT
  NEXT

'*******************************************************************
'                                   Now we despeckle
'*******************************************************************

  FOR y = 1 TO gH - 2
    FOR x = gW - 1 TO 1 STEP -1
      r1 = GRB(x,y)
      g1 = GGB(x,y)
      b1 = GBB(x,y)

      r2 = GRB(x+1,y)
      g2 = GGB(x+1,y)
      b2 = GBB(x+1,y)

      r3 = GRB(x-1,y)
      g3 = GGB(x-1,y)
      b3 = GBB(x-1,y)

      IF (r1>r2 OR r1>r3) AND (g1>g2 OR g1>g3) AND (b1>b2 OR b1>b3) THEN

        SetRedByte   (x,y,(r2+r3)*0.5)
        SetGreenByte (x,y,(g2+g3)*0.5)
        SetBlueByte  (x,y,(b2+b3)*0.5)
      END IF
    NEXT
  NEXT

  FOR x = gW - 1 TO 1 STEP -1
    FOR y = 1 TO gH - 2

      r1 = GRB (x,y)
      g1 = GGB (x,y)
      b1 = GBB (x,y)

      r2 = GRB(x,y+1)
      g2 = GGB(x,y+1)
      b2 = GBB(x,y+1)

      r3 = GRB(x,y-1)
      g3 = GGB(x,y-1)
      b3 = GBB(x,y-1)

      IF (r1+g1+b1=765) AND (r2+g2+b2<765) AND (r3+g3+b3<765) THEN
        SetRedByte   (x,y,(r2+r3)*0.5)
        SetGreenByte (x,y,(g2+g3)*0.5)
        SetBlueByte  (x,y,(b2+b3)*0.5)
      END IF
    NEXT
  NEXT

'*****************************************************************************
  SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)

  DeleteDC (hMemDC)
  DeleteDC (hDestDC)
  DeleteDC (hDC)
  GlobalFree ((HGLOBAL) glpBits)
  GlobalFree ((HGLOBAL) pbmi)
  FUNCTION = hBmp
END FUNCTION








FUNCTION Emboss OPTIONAL (bmpSource AS HBITMAP, Kolor =5921370 ) AS HBITMAP
'************************************************************************
'      bmpSource is not modified
'************************************************************************
DIM pbmi   AS PBITMAPINFO
DIM pbih     AS PBITMAPINFOHEADER
DIM hMemDC   AS HDC
DIM hDestDC  AS HDC
DIM hDC      AS HDC
DIM hBmp     AS HBITMAP
DIM bmp      AS BITMAP
DIM cClrBits AS WORD
DIM R,G,B
'***********************************************
gH = BCX_BMPHEIGHT(bmpSource)
gW = BCX_BMPWIDTH (bmpSource)

hMemDC = CreateCompatibleDC(NULL)
SelectObject(hMemDC, bmpSource)
hDestDC = CreateCompatibleDC(hMemDC)
hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
SelectObject(hDestDC,hBmp)
BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

SELECT CASE cClrBits
  CASE     1   : cClrBits =  1
  CASE <=  4   : cClrBits =  4
  CASE <=  8   : cClrBits =  8
  CASE <= 16   : cClrBits = 16
  CASE <= 24   : cClrBits = 24
  CASE ELSE    : cClrBits = 32
END SELECT

IF cClrBits < 24 THEN
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
ELSE
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
END IF

pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
pbmi->bmiHeader.biWidth    = bmp.bmWidth
pbmi->bmiHeader.biHeight   = bmp.bmHeight
pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

IF cClrBits < 24 THEN
  pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
ELSE
  pbmi->bmiHeader.biClrUsed = 0
END IF

pbmi->bmiHeader.biCompression = BI_RGB
pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
pbmi->bmiHeader.biClrImportant = 0

pbih = (PBITMAPINFOHEADER) pbmi
glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

IF NOT glpBits THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

hDC = CreateCompatibleDC (NULL)

IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

'**************************************************************
'                       Start Emboss Filter
'**************************************************************

DIM RAW cR = GETRVALUE(Kolor)
DIM RAW cG = GETGVALUE(Kolor)
DIM RAW cB = GETBVALUE(Kolor)

REGISTER X
REGISTER Y

FOR Y = 1 TO gH - 1
  FOR X = 1 TO gW - 1
    B = ABS(GRB(X,Y) - GRB(X+1,Y+1) + cB)
    G = ABS(GGB(X,Y) - GGB(X+1,Y+1) + cG)
    R = ABS(GBB(X,Y) - GBB(X+1,Y+1) + cR)

    R = MIN(MAX(R, 0), 255)
    G = MIN(MAX(G, 0), 255)
    B = MIN(MAX(B, 0), 255)

    SetRedByte   (X, Y, R)
    SetGreenByte (X, Y, G)
    SetBlueByte  (X, Y, B)

  NEXT
NEXT

'**************************************************************
'                       End Emboss Filter
'**************************************************************
SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
DeleteDC (hMemDC)
DeleteDC (hDestDC)
DeleteDC (hDC)

GlobalFree ((HGLOBAL) glpBits)
GlobalFree ((HGLOBAL) pbmi)
FUNCTION = hBmp
END FUNCTION






FUNCTION Engrave OPTIONAL (bmpSource AS HBITMAP, Kolor =5921370 ) AS HBITMAP
'************************************************************************
'      bmpSource is not modified
'************************************************************************
DIM pbmi   AS PBITMAPINFO
DIM pbih     AS PBITMAPINFOHEADER
DIM hMemDC   AS HDC
DIM hDestDC  AS HDC
DIM hDC      AS HDC
DIM hBmp     AS HBITMAP
DIM bmp      AS BITMAP
DIM cClrBits AS WORD
DIM R,G,B
'***********************************************
gH = BCX_BMPHEIGHT(bmpSource)
gW = BCX_BMPWIDTH (bmpSource)

hMemDC = CreateCompatibleDC(NULL)
SelectObject(hMemDC, bmpSource)
hDestDC = CreateCompatibleDC(hMemDC)
hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
SelectObject(hDestDC,hBmp)
BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

SELECT CASE cClrBits
  CASE     1   : cClrBits =  1
  CASE <=  4   : cClrBits =  4
  CASE <=  8   : cClrBits =  8
  CASE <= 16   : cClrBits = 16
  CASE <= 24   : cClrBits = 24
  CASE ELSE    : cClrBits = 32
END SELECT

IF cClrBits < 24 THEN
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
ELSE
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
END IF

pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
pbmi->bmiHeader.biWidth    = bmp.bmWidth
pbmi->bmiHeader.biHeight   = bmp.bmHeight
pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

IF cClrBits < 24 THEN
  pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
ELSE
  pbmi->bmiHeader.biClrUsed = 0
END IF

pbmi->bmiHeader.biCompression = BI_RGB
pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
pbmi->bmiHeader.biClrImportant = 0

pbih = (PBITMAPINFOHEADER) pbmi
glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

IF NOT glpBits THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

hDC = CreateCompatibleDC (NULL)

IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

'**************************************************************
'                       Start Engrave Filter
'**************************************************************

DIM RAW cR = GETRVALUE(Kolor)
DIM RAW cG = GETGVALUE(Kolor)
DIM RAW cB = GETBVALUE(Kolor)

REGISTER X
REGISTER Y

FOR Y = 1 TO gH - 1
  FOR X = 1 TO gW - 1
    B = ABS(GRB(X,Y) - GRB(X+1,Y+1) - cB)
    G = ABS(GGB(X,Y) - GGB(X+1,Y+1) - cG)
    R = ABS(GBB(X,Y) - GBB(X+1,Y+1) - cR)

    R = MIN(MAX(R, 0), 255)
    G = MIN(MAX(G, 0), 255)
    B = MIN(MAX(B, 0), 255)

    SetRedByte   (X, Y, R)
    SetGreenByte (X, Y, G)
    SetBlueByte  (X, Y, B)

  NEXT
NEXT

'**************************************************************
'                       End Engrave Filter
'**************************************************************
SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
DeleteDC (hMemDC)
DeleteDC (hDestDC)
DeleteDC (hDC)

GlobalFree ((HGLOBAL) glpBits)
GlobalFree ((HGLOBAL) pbmi)
FUNCTION = hBmp
END FUNCTION








FUNCTION EdgeEnhance OPTIONAL (bmpSource AS HBITMAP, Factor = 10) AS HBITMAP
'************************************************************************
'      bmpSource is not modified
'************************************************************************
DIM pbmi   AS PBITMAPINFO
DIM pbih     AS PBITMAPINFOHEADER
DIM hMemDC   AS HDC
DIM hDestDC  AS HDC
DIM hDC      AS HDC
DIM hBmp     AS HBITMAP
DIM bmp      AS BITMAP
DIM cClrBits AS WORD
DIM R,G,B
'***********************************************
gH = BCX_BMPHEIGHT(bmpSource)
gW = BCX_BMPWIDTH (bmpSource)

hMemDC = CreateCompatibleDC(NULL)
SelectObject(hMemDC, bmpSource)
hDestDC = CreateCompatibleDC(hMemDC)
hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
SelectObject(hDestDC,hBmp)
BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

SELECT CASE cClrBits
  CASE     1   : cClrBits =  1
  CASE <=  4   : cClrBits =  4
  CASE <=  8   : cClrBits =  8
  CASE <= 16   : cClrBits = 16
  CASE <= 24   : cClrBits = 24
  CASE ELSE    : cClrBits = 32
END SELECT

IF cClrBits < 24 THEN
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
ELSE
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
END IF

pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
pbmi->bmiHeader.biWidth    = bmp.bmWidth
pbmi->bmiHeader.biHeight   = bmp.bmHeight
pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

IF cClrBits < 24 THEN
  pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
ELSE
  pbmi->bmiHeader.biClrUsed = 0
END IF

pbmi->bmiHeader.biCompression = BI_RGB
pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
pbmi->bmiHeader.biClrImportant = 0

pbih = (PBITMAPINFOHEADER) pbmi
glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

IF NOT glpBits THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

hDC = CreateCompatibleDC (NULL)

IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

'**************************************************************
'                       Start Edge Enhance Filter
'**************************************************************

DIM mf AS Single, dF AS Single

REGISTER X
REGISTER Y

mf = 9.0 + Factor
dF = 1.0 + Factor

FOR Y = 1 TO gH - 1
  FOR X = 1 TO gW - 1

    R = GRB (X - 1, Y - 1) + GRB (X - 1, Y) + GRB (X - 1, Y + 1) + GRB (X, Y - 1) + _
    GRB (X, Y + 1) + GRB (X + 1, Y - 1) + GRB (X + 1, Y) + GRB (X + 1, Y + 1)
    R = (mf * GRB (X, Y) - R) / dF

    G = GGB (X - 1, Y - 1) + GGB (X - 1, Y) + GGB (X - 1, Y + 1) + GGB (X, Y - 1) + _
    GGB (X, Y + 1) + GGB (X + 1, Y - 1) + GGB (X + 1, Y) + GGB (X + 1, Y + 1)
    G = (mf * GGB (X, Y) - G) / dF

    B = GBB (X - 1, Y - 1) + GBB (X - 1, Y) + GBB (X - 1, Y + 1) + GBB (X, Y - 1) + _
    GBB (X, Y + 1) + GBB (X + 1, Y - 1) +  GBB (X + 1, Y) + GBB (X + 1, Y + 1)
    B = (mf * GBB (X, Y) - B) / dF

    R = MIN(MAX(R, 0), 255)
    G = MIN(MAX(G, 0), 255)
    B = MIN(MAX(B, 0), 255)

    SetRedByte   (X, Y, R)
    SetGreenByte (X, Y, G)
    SetBlueByte  (X, Y, B)

  NEXT
NEXT

'**************************************************************
'                       End Edge Enhance Filter
'**************************************************************
SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
DeleteDC (hMemDC)
DeleteDC (hDestDC)
DeleteDC (hDC)

GlobalFree ((HGLOBAL) glpBits)
GlobalFree ((HGLOBAL) pbmi)
FUNCTION = hBmp
END FUNCTION











FUNCTION Gamma (bmpSource AS HBITMAP, Factor) AS HBITMAP
'************************************************************************
'      bmpSource is not modified
'************************************************************************
  DIM pbmi   AS PBITMAPINFO
  DIM pbih     AS PBITMAPINFOHEADER
  DIM hMemDC   AS HDC
  DIM hDestDC  AS HDC
  DIM hDC      AS HDC
  DIM hBmp     AS HBITMAP
  DIM bmp      AS BITMAP
  DIM cClrBits AS WORD
  DIM R,G,B
'***********************************************
  gH = BCX_BMPHEIGHT(bmpSource)
  gW = BCX_BMPWIDTH (bmpSource)

  hMemDC = CreateCompatibleDC(NULL)
  SelectObject(hMemDC, bmpSource)
  hDestDC = CreateCompatibleDC(hMemDC)
  hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
  SelectObject(hDestDC,hBmp)
  BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

  IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

  SELECT CASE cClrBits
    CASE     1   : cClrBits =  1
    CASE <=  4   : cClrBits =  4
    CASE <=  8   : cClrBits =  8
    CASE <= 16   : cClrBits = 16
    CASE <= 24   : cClrBits = 24
    CASE ELSE    : cClrBits = 32
  END SELECT

  IF cClrBits < 24 THEN
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
  ELSE
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
  END IF

  pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
  pbmi->bmiHeader.biWidth    = bmp.bmWidth
  pbmi->bmiHeader.biHeight   = bmp.bmHeight
  pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
  pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

  IF cClrBits < 24 THEN
    pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
  ELSE
    pbmi->bmiHeader.biClrUsed = 0
  END IF

  pbmi->bmiHeader.biCompression = BI_RGB
  pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
  pbmi->bmiHeader.biClrImportant = 0

  pbih = (PBITMAPINFOHEADER) pbmi
  glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

  IF NOT glpBits THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  hDC = CreateCompatibleDC (NULL)

  IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

'**************************************************************
'                       Start Gamma Correction Filter
'**************************************************************

  DIM dB AS Double, dG AS Double, dR AS Double, sF AS Single

  REGISTER X
  REGISTER Y

  sF = Factor * 0.01

  FOR Y = 1 TO gH
    FOR X = 1 TO gW
'get data
      R = GRB( X, Y)
      G = GGB( X, Y)
      B = GBB( X, Y)
      dB = B / 255.0
      dG = G / 255.0
      dR = R / 255.0

'correct gamma

      dB = dB ^ (1.0 / sF)
      dG = dG ^ (1.0 / sF)
      dR = dR ^ (1.0 / sF)

'set data

      B = dB * 255
      G = dG * 255
      R = dR * 255

      R = MIN(MAX(R, 0), 255)
      G = MIN(MAX(G, 0), 255)
      B = MIN(MAX(B, 0), 255)

      SetRedByte   (X, Y, R)
      SetGreenByte (X, Y, G)
      SetBlueByte  (X, Y, B)
    NEXT
  NEXT


'**************************************************************
'                       End Gamma Filter
'**************************************************************
  SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
  DeleteDC (hMemDC)
  DeleteDC (hDestDC)
  DeleteDC (hDC)

  GlobalFree ((HGLOBAL) glpBits)
  GlobalFree ((HGLOBAL) pbmi)
  FUNCTION = hBmp
END FUNCTION










FUNCTION Saturate (bmpSource AS HBITMAP, Factor) AS HBITMAP
'************************************************************************
'      bmpSource is not modified
'************************************************************************
  DIM pbmi   AS PBITMAPINFO
  DIM pbih     AS PBITMAPINFOHEADER
  DIM hMemDC   AS HDC
  DIM hDestDC  AS HDC
  DIM hDC      AS HDC
  DIM hBmp     AS HBITMAP
  DIM bmp      AS BITMAP
  DIM cClrBits AS WORD
  DIM R,G,B
'***********************************************
  gH = BCX_BMPHEIGHT(bmpSource)
  gW = BCX_BMPWIDTH (bmpSource)

  hMemDC = CreateCompatibleDC(NULL)
  SelectObject(hMemDC, bmpSource)
  hDestDC = CreateCompatibleDC(hMemDC)
  hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
  SelectObject(hDestDC,hBmp)
  BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

  IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

  SELECT CASE cClrBits
    CASE     1   : cClrBits =  1
    CASE <=  4   : cClrBits =  4
    CASE <=  8   : cClrBits =  8
    CASE <= 16   : cClrBits = 16
    CASE <= 24   : cClrBits = 24
    CASE ELSE    : cClrBits = 32
  END SELECT

  IF cClrBits < 24 THEN
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
  ELSE
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
  END IF

  pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
  pbmi->bmiHeader.biWidth    = bmp.bmWidth
  pbmi->bmiHeader.biHeight   = bmp.bmHeight
  pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
  pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

  IF cClrBits < 24 THEN
    pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
  ELSE
    pbmi->bmiHeader.biClrUsed = 0
  END IF

  pbmi->bmiHeader.biCompression = BI_RGB
  pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
  pbmi->bmiHeader.biClrImportant = 0

  pbih = (PBITMAPINFOHEADER) pbmi
  glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

  IF NOT glpBits THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  hDC = CreateCompatibleDC (NULL)

  IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

'**************************************************************
'                       Start Color Saturation Filter
'**************************************************************
  DIM Speed! [766]
  DIM V AS Long
  DIM sF AS Single

  REGISTER X
  REGISTER Y

  FOR X = 0 TO 765
    Speed[X] = X * 0.333
  NEXT X

  sF = Factor / 100.0
  FOR Y = 1 TO gH
    FOR X = 1 TO gW
      R = GRB( X, Y)
      G = GGB( X, Y)
      B = GBB( X, Y)

      V = Speed[B + G + R]
      B = B + sF * (B - V)
      G = G + sF * (G - V)
      R = R + sF * (R - V)

      R = MIN(MAX(R, 0), 255)
      G = MIN(MAX(G, 0), 255)
      B = MIN(MAX(B, 0), 255)

      SetRedByte   (X, Y, R)
      SetGreenByte (X, Y, G)
      SetBlueByte  (X, Y, B)

    NEXT
  NEXT

'**************************************************************
'                       End Color Saturation Filter
'**************************************************************
  SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
  DeleteDC (hMemDC)
  DeleteDC (hDestDC)
  DeleteDC (hDC)

  GlobalFree ((HGLOBAL) glpBits)
  GlobalFree ((HGLOBAL) pbmi)
  FUNCTION = hBmp
END FUNCTION








FUNCTION ConnectedContour (bmpSource AS HBITMAP) AS HBITMAP
'************************************************************************
'      bmpSource is not modified
'************************************************************************
  DIM pbmi   AS PBITMAPINFO
  DIM pbih     AS PBITMAPINFOHEADER
  DIM hMemDC   AS HDC
  DIM hDestDC  AS HDC
  DIM hDC      AS HDC
  DIM hBmp     AS HBITMAP
  DIM bmp      AS BITMAP
  DIM cClrBits AS WORD
  DIM R,G,B
'***********************************************
  gH = BCX_BMPHEIGHT(bmpSource)
  gW = BCX_BMPWIDTH (bmpSource)

  hMemDC = CreateCompatibleDC(NULL)
  SelectObject(hMemDC, bmpSource)
  hDestDC = CreateCompatibleDC(hMemDC)
  hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
  SelectObject(hDestDC,hBmp)
  BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

  IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

  SELECT CASE cClrBits
    CASE     1   : cClrBits =  1
    CASE <=  4   : cClrBits =  4
    CASE <=  8   : cClrBits =  8
    CASE <= 16   : cClrBits = 16
    CASE <= 24   : cClrBits = 24
    CASE ELSE    : cClrBits = 32
  END SELECT

  IF cClrBits < 24 THEN
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
  ELSE
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
  END IF

  pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
  pbmi->bmiHeader.biWidth    = bmp.bmWidth
  pbmi->bmiHeader.biHeight   = bmp.bmHeight
  pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
  pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

  IF cClrBits < 24 THEN
    pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
  ELSE
    pbmi->bmiHeader.biClrUsed = 0
  END IF

  pbmi->bmiHeader.biCompression = BI_RGB
  pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
  pbmi->bmiHeader.biClrImportant = 0

  pbih = (PBITMAPINFOHEADER) pbmi
  glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)



  IF NOT glpBits THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  hDC = CreateCompatibleDC (NULL)

  IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

'**************************************************************
'                       Start Connected Contour Filter
'**************************************************************
  gClone = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)
  GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,gClone, pbmi, DIB_RGB_COLORS)
'**************************************************************

  DIM V AS Long
  DIM vMin AS Long

  REGISTER X
  REGISTER Y
  REGISTER I

  FOR Y = 1 TO gH - 2
    FOR X = 1 TO gW - 2
      FOR I = 0 TO 2

        vMin = 255
        V = GCB(I,X - 1, Y - 1)
        IF V < vMin THEN vMin = V
        V = GCB(I,X, Y - 1)
        IF V < vMin THEN vMin = V
        V = GCB(I,X + 1, Y - 1)
        IF V < vMin THEN vMin = V

        V = GCB(I,X - 1, Y)
        IF V < vMin THEN vMin = V
        V = GCB(I,X, Y)
        IF V < vMin THEN vMin = V
        V = GCB(I,X + 1, Y)
        IF V < vMin THEN vMin = V

        V = GCB(I,X - 1, Y + 1)
        IF V < vMin THEN vMin = V
        V = GCB(I,X, Y + 1)
        IF V < vMin THEN vMin = V
        V = GCB(I,X + 1, Y + 1)
        IF V < vMin THEN vMin = V

        SetAnyByte(I,X, Y, GCB(I,X,Y) - vMin)

      NEXT
    NEXT
  NEXT

'**************************************************************
'                       End Connected Contour Filter
'**************************************************************
  SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
  DeleteDC (hMemDC)
  DeleteDC (hDestDC)
  DeleteDC (hDC)

  GlobalFree ((HGLOBAL) gClone)
  GlobalFree ((HGLOBAL) glpBits)
  GlobalFree ((HGLOBAL) pbmi)

  FUNCTION = hBmp
END FUNCTION












FUNCTION WaterColor (bmpSource AS HBITMAP) AS HBITMAP
'************************************************************************
'      bmpSource is not modified
'************************************************************************
  DIM pbmi   AS PBITMAPINFO
  DIM pbih     AS PBITMAPINFOHEADER
  DIM hMemDC   AS HDC
  DIM hDestDC  AS HDC
  DIM hDC      AS HDC
  DIM hBmp     AS HBITMAP
  DIM bmp      AS BITMAP
  DIM cClrBits AS WORD
  DIM R,G,B
'***********************************************
  gH = BCX_BMPHEIGHT(bmpSource)
  gW = BCX_BMPWIDTH (bmpSource)

  hMemDC = CreateCompatibleDC(NULL)
  SelectObject(hMemDC, bmpSource)
  hDestDC = CreateCompatibleDC(hMemDC)
  hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
  SelectObject(hDestDC,hBmp)
  BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

  IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

  SELECT CASE cClrBits
    CASE     1   : cClrBits =  1
    CASE <=  4   : cClrBits =  4
    CASE <=  8   : cClrBits =  8
    CASE <= 16   : cClrBits = 16
    CASE <= 24   : cClrBits = 24
    CASE ELSE    : cClrBits = 32
  END SELECT

  IF cClrBits < 24 THEN
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
  ELSE
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
  END IF

  pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
  pbmi->bmiHeader.biWidth    = bmp.bmWidth
  pbmi->bmiHeader.biHeight   = bmp.bmHeight
  pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
  pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

  IF cClrBits < 24 THEN
    pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
  ELSE
    pbmi->bmiHeader.biClrUsed = 0
  END IF

  pbmi->bmiHeader.biCompression = BI_RGB
  pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
  pbmi->bmiHeader.biClrImportant = 0

  pbih = (PBITMAPINFOHEADER) pbmi
  glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)



  IF NOT glpBits THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  hDC = CreateCompatibleDC (NULL)

  IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

'**************************************************************
'                       Start WaterColor Filter
'**************************************************************
  gClone = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)
  GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,gClone, pbmi, DIB_RGB_COLORS)
'**************************************************************

  DIM Med[4] AS Long
  DIM Dev[4] AS Long
  DIM sDev AS Long
  DIM vDev AS Long

  REGISTER X
  REGISTER Y
  REGISTER I

  FOR Y = 3 TO gH - 3
    FOR X = 3 TO gW - 3
      FOR I = 0 TO 3
        Med[0] = GCB(I, X - 2, Y - 2) + GCB(I, X - 1, Y - 2) + GCB(I, X, Y - 2) +  GCB(I, X - 2, Y - 1) + _
        GCB(I, X - 1, Y - 1) + GCB(I, X, Y - 1) +  GCB(I, X - 2, Y) + GCB(I, X - 1, Y) + GCB(I, X, Y)

        Med[1] = GCB(I, X + 2, Y - 2) + GCB(I, X + 1, Y - 2) + GCB(I, X, Y - 2) + GCB(I, X + 2, Y - 1) + _
        GCB(I, X + 1, Y - 1) + GCB(I, X, Y - 1) + GCB(I, X + 2, Y) + GCB(I, X + 1, Y) + GCB(I, X, Y)

        Med[2] = GCB(I, X - 2, Y + 2) + GCB(I, X - 1, Y + 2) + GCB(I, X, Y + 2) + GCB(I, X - 2, Y + 1) + _
        GCB(I, X - 1, Y + 1) + GCB(I, X, Y + 1) + GCB(I, X - 2, Y) + GCB(I, X - 1, Y) + GCB(I, X, Y)

        Med[3] = GCB(I, X + 2, Y + 2) + GCB(I, X + 1, Y + 2) + GCB(I, X, Y + 2) + GCB(I, X + 2, Y + 1) + _
        GCB(I, X + 1, Y + 1) + GCB(I, X, Y + 1) + GCB(I, X + 2, Y) + GCB(I, X + 1, Y) + GCB(I, X, Y)

        Med[0] = Med[0] * 0.111
        Med[1] = Med[1] * 0.111
        Med[2] = Med[2] * 0.111
        Med[3] = Med[3] * 0.111

        Dev[0] = ABS(GCB(I, X - 2, Y - 2) - Med[0]) + ABS(GCB(I, X - 1, Y - 2) - Med[0]) + ABS(GCB(I, X, Y - 2) - Med[0]) + _
        ABS(GCB(I, X - 2, Y - 1) - Med[0]) + ABS(GCB(I, X - 1, Y - 1) - Med[0]) + ABS(GCB(I, X, Y - 1) - Med[0]) + _
        ABS(GCB(I, X - 2, Y) - Med[0]) + ABS(GCB(I, X - 1, Y) - Med[0]) + ABS(GCB(I, X, Y) - Med[0])

        Dev[1] = ABS(GCB(I, X + 2, Y - 2) - Med[1]) + ABS(GCB(I, X + 1, Y - 2) - Med[1]) + ABS(GCB(I, X, Y - 2) - Med[1]) + _
        ABS(GCB(I, X + 2, Y - 1) - Med[1]) + ABS(GCB(I, X + 1, Y - 1) - Med[1]) + ABS(GCB(I, X, Y - 1) - Med[1]) + _
        ABS(GCB(I, X + 2, Y) - Med[1]) + ABS(GCB(I, X + 1, Y) - Med[1]) + ABS(GCB(I, X, Y) - Med[1])

        Dev[2] = ABS(GCB(I, X - 2, Y + 2) - Med[2]) + ABS(GCB(I, X - 1, Y + 2) - Med[2]) + ABS(GCB(I, X, Y + 2) - Med[2]) + _
        ABS(GCB(I, X - 2, Y + 1) - Med[2]) + ABS(GCB(I, X - 1, Y + 1) - Med[2]) + ABS(GCB(I, X, Y + 1) - Med[2]) + _
        ABS(GCB(I, X - 2, Y) - Med[2]) + ABS(GCB(I, X - 1, Y) - Med[2]) + ABS(GCB(I, X, Y) - Med[2])

        Dev[3] = ABS(GCB(I, X + 2, Y + 2) - Med[3]) + ABS(GCB(I, X + 1, Y + 2) - Med[3]) + ABS(GCB(I, X, Y + 2) - Med[3]) + _
        ABS(GCB(I, X + 2, Y + 1) - Med[3]) + ABS(GCB(I, X + 1, Y + 1) - Med[3]) + ABS(GCB(I, X, Y + 1) - Med[3]) + _
        ABS(GCB(I, X + 2, Y) - Med[3]) + ABS(GCB(I, X + 1, Y) - Med[3]) + ABS(GCB(I, X, Y) - Med[3])

        vDev = 99999
        sDev = 0

        FOR INTEGER j = 0 TO 3
          IF Dev[j] < vDev THEN
            vDev = Dev[j]
            sDev = j
          END IF
        NEXT

        SetAnyByte(I, X, Y, Med[sDev])
      NEXT
    NEXT
  NEXT

'**************************************************************
'                       End WaterColor Filter
'**************************************************************
  SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
  DeleteDC (hMemDC)
  DeleteDC (hDestDC)
  DeleteDC (hDC)

  GlobalFree ((HGLOBAL) gClone)
  GlobalFree ((HGLOBAL) glpBits)
  GlobalFree ((HGLOBAL) pbmi)

  FUNCTION = hBmp
END FUNCTION








FUNCTION Blur (bmpSource AS HBITMAP) AS HBITMAP
'************************************************************************
'      bmpSource is not modified
'************************************************************************
  DIM pbmi   AS PBITMAPINFO
  DIM pbih     AS PBITMAPINFOHEADER
  DIM hMemDC   AS HDC
  DIM hDestDC  AS HDC
  DIM hDC      AS HDC
  DIM hBmp     AS HBITMAP
  DIM bmp      AS BITMAP
  DIM cClrBits AS WORD
  DIM R,G,B
'***********************************************
  gH = BCX_BMPHEIGHT(bmpSource)
  gW = BCX_BMPWIDTH (bmpSource)

  hMemDC = CreateCompatibleDC(NULL)
  SelectObject(hMemDC, bmpSource)
  hDestDC = CreateCompatibleDC(hMemDC)
  hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
  SelectObject(hDestDC,hBmp)
  BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

  IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

  SELECT CASE cClrBits
    CASE     1   : cClrBits =  1
    CASE <=  4   : cClrBits =  4
    CASE <=  8   : cClrBits =  8
    CASE <= 16   : cClrBits = 16
    CASE <= 24   : cClrBits = 24
    CASE ELSE    : cClrBits = 32
  END SELECT

  IF cClrBits < 24 THEN
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
  ELSE
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
  END IF

  pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
  pbmi->bmiHeader.biWidth    = bmp.bmWidth
  pbmi->bmiHeader.biHeight   = bmp.bmHeight
  pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
  pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

  IF cClrBits < 24 THEN
    pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
  ELSE
    pbmi->bmiHeader.biClrUsed = 0
  END IF

  pbmi->bmiHeader.biCompression = BI_RGB
  pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
  pbmi->bmiHeader.biClrImportant = 0

  pbih = (PBITMAPINFOHEADER) pbmi
  glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

  IF NOT glpBits THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  hDC = CreateCompatibleDC (NULL)

  IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

'**************************************************************
'                       Start Blur Filter
'**************************************************************
  REGISTER X
  REGISTER Y

  FOR Y = 2 TO gH - 1
    FOR X = 2 TO gW - 1

      R = GRB(X-1,Y-1) + GRB(X-1,Y) + GRB(X-1,Y+1) + GRB(X,Y-1) + GRB(X,Y+1) + GRB(X+1,Y-1) + GRB(X+1,Y) + GRB(X+1,Y+1)
      G = GGB(X-1,Y-1) + GGB(X-1,Y) + GGB(X-1,Y+1) + GGB(X,Y-1) + GGB(X,Y+1) + GGB(X+1,Y-1) + GGB(X+1,Y) + GGB(X+1,Y+1)
      B = GBB(X-1,Y-1) + GBB(X-1,Y) + GBB(X-1,Y+1) + GBB(X,Y-1) + GBB(X,Y+1) + GBB(X+1,Y-1) + GBB(X+1,Y) + GBB(X+1,Y+1)

      R = R * 0.125
      G = G * 0.125
      B = B * 0.125

      SetRedByte   (X, Y, R)
      SetGreenByte (X, Y, G)
      SetBlueByte  (X, Y, B)

    NEXT
  NEXT

'**************************************************************
'                       End Blur Filter
'**************************************************************
  SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
  DeleteDC (hMemDC)
  DeleteDC (hDestDC)
  DeleteDC (hDC)

  GlobalFree ((HGLOBAL) glpBits)
  GlobalFree ((HGLOBAL) pbmi)
  FUNCTION = hBmp
END FUNCTION











FUNCTION Contour OPTIONAL (bmpSource AS HBITMAP, BackColor = 16777215)  AS HBITMAP
'************************************************************************
'      bmpSource is not modified
'************************************************************************
DIM pbmi   AS PBITMAPINFO
DIM pbih     AS PBITMAPINFOHEADER
DIM hMemDC   AS HDC
DIM hDestDC  AS HDC
DIM hDC      AS HDC
DIM hBmp     AS HBITMAP
DIM bmp      AS BITMAP
DIM cClrBits AS WORD
DIM R,G,B
'***********************************************
gH = BCX_BMPHEIGHT(bmpSource)
gW = BCX_BMPWIDTH (bmpSource)

hMemDC = CreateCompatibleDC(NULL)
SelectObject(hMemDC, bmpSource)
hDestDC = CreateCompatibleDC(hMemDC)
hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
SelectObject(hDestDC,hBmp)
BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

SELECT CASE cClrBits
  CASE     1   : cClrBits =  1
  CASE <=  4   : cClrBits =  4
  CASE <=  8   : cClrBits =  8
  CASE <= 16   : cClrBits = 16
  CASE <= 24   : cClrBits = 24
  CASE ELSE    : cClrBits = 32
END SELECT

IF cClrBits < 24 THEN
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
ELSE
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
END IF

pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
pbmi->bmiHeader.biWidth    = bmp.bmWidth
pbmi->bmiHeader.biHeight   = bmp.bmHeight
pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

IF cClrBits < 24 THEN
  pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
ELSE
  pbmi->bmiHeader.biClrUsed = 0
END IF

pbmi->bmiHeader.biCompression = BI_RGB
pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
pbmi->bmiHeader.biClrImportant = 0

pbih = (PBITMAPINFOHEADER) pbmi
glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

IF NOT glpBits THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

hDC = CreateCompatibleDC (NULL)

IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

'**************************************************************
'                       Start Contour Filter
'**************************************************************
gClone = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)
GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,gClone, pbmi, DIB_RGB_COLORS)
'**************************************************************

DIM cB AS Long, cG AS Long, cR AS Long

REGISTER X
REGISTER Y

cR = GETRVALUE (BackColor)
cG = GETGVALUE (BackColor)
cB = GETBVALUE (BackColor)

FOR Y = 2 TO gH - 2
  FOR X = 2 TO gW - 2

    R = GCB(0,X-1,Y-1) + GCB(0,X-1,Y) + GCB(0,X-1,Y+1) + GCB(0,X,Y-1) + GCB(0,X,Y+1) + GCB(0,X+1,Y-1) + GCB(0,X+1,Y) + GCB(0,X+1,Y+1)
    G = GCB(1,X-1,Y-1) + GCB(1,X-1,Y) + GCB(1,X-1,Y+1) + GCB(1,X,Y-1) + GCB(1,X,Y+1) + GCB(1,X+1,Y-1) + GCB(1,X+1,Y) + GCB(1,X+1,Y+1)
    B = GCB(2,X-1,Y-1) + GCB(2,X-1,Y) + GCB(2,X-1,Y+1) + GCB(2,X,Y-1) + GCB(2,X,Y+1) + GCB(2,X+1,Y-1) + GCB(2,X+1,Y) + GCB(2,X+1,Y+1)

    B = 8 * GCB( 2,X, Y) - B + cB
    G = 8 * GCB( 1,X, Y) - G + cG
    R = 8 * GCB( 0,X, Y) - R + cR

    R = MIN(MAX(R, 0), 255)
    G = MIN(MAX(G, 0), 255)
    B = MIN(MAX(B, 0), 255)

    SetRedByte   (X, Y, R)
    SetGreenByte (X, Y, G)
    SetBlueByte  (X, Y, B)

  NEXT
NEXT

'**************************************************************
'                       End Contour Filter
'**************************************************************
SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
DeleteDC (hMemDC)
DeleteDC (hDestDC)
DeleteDC (hDC)

GlobalFree ((HGLOBAL) gClone)
GlobalFree ((HGLOBAL) glpBits)
GlobalFree ((HGLOBAL) pbmi)
FUNCTION = hBmp
END FUNCTION










FUNCTION EmbossMore OPTIONAL (bmpSource AS HBITMAP, BackColor = 5921370)  AS HBITMAP
'************************************************************************
'      bmpSource is not modified
'************************************************************************
DIM pbmi   AS PBITMAPINFO
DIM pbih     AS PBITMAPINFOHEADER
DIM hMemDC   AS HDC
DIM hDestDC  AS HDC
DIM hDC      AS HDC
DIM hBmp     AS HBITMAP
DIM bmp      AS BITMAP
DIM cClrBits AS WORD
DIM R,G,B
'***********************************************
gH = BCX_BMPHEIGHT(bmpSource)
gW = BCX_BMPWIDTH (bmpSource)

hMemDC = CreateCompatibleDC(NULL)
SelectObject(hMemDC, bmpSource)
hDestDC = CreateCompatibleDC(hMemDC)
hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
SelectObject(hDestDC,hBmp)
BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

SELECT CASE cClrBits
  CASE     1   : cClrBits =  1
  CASE <=  4   : cClrBits =  4
  CASE <=  8   : cClrBits =  8
  CASE <= 16   : cClrBits = 16
  CASE <= 24   : cClrBits = 24
  CASE ELSE    : cClrBits = 32
END SELECT

IF cClrBits < 24 THEN
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
ELSE
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
END IF

pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
pbmi->bmiHeader.biWidth    = bmp.bmWidth
pbmi->bmiHeader.biHeight   = bmp.bmHeight
pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

IF cClrBits < 24 THEN
  pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
ELSE
  pbmi->bmiHeader.biClrUsed = 0
END IF

pbmi->bmiHeader.biCompression = BI_RGB
pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
pbmi->bmiHeader.biClrImportant = 0

pbih = (PBITMAPINFOHEADER) pbmi
glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

IF NOT glpBits THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

hDC = CreateCompatibleDC (NULL)

IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

'**************************************************************
'                       Start EmbossMore Filter
'**************************************************************
gClone = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)
GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,gClone, pbmi, DIB_RGB_COLORS)
'**************************************************************

DIM cB AS Long, cG AS Long, cR AS Long

REGISTER X
REGISTER Y

cR = GETRVALUE (BackColor)
cG = GETGVALUE (BackColor)
cB = GETBVALUE (BackColor)

FOR Y = 2 TO gH - 2
  FOR X = 2 TO gW - 2

    B = GCB(0, X - 1, Y - 1) - GCB(0, X + 1, Y - 1) + _
    GCB(0, X - 1, Y) - GCB(0, X + 1, Y) + _
    GCB(0, X - 1, Y + 1) - GCB(0, X + 1, Y + 1) + cB

    G = GCB(1, X - 1, Y - 1) - GCB(1, X + 1, Y - 1) + _
    GCB(1, X - 1, Y) - GCB(1, X + 1, Y) + _
    GCB(1, X - 1, Y + 1) - GCB(1, X + 1, Y + 1) + cG

    R = GCB(2, X - 1, Y - 1) - GCB(2, X + 1, Y - 1) + _
    GCB(2, X - 1, Y) - GCB(2, X + 1, Y) + _
    GCB(2, X - 1, Y + 1) - GCB(2, X + 1, Y + 1) + cR

    R = MIN(MAX(R, 0), 255)
    G = MIN(MAX(G, 0), 255)
    B = MIN(MAX(B, 0), 255)

    SetRedByte   (X, Y, R)
    SetGreenByte (X, Y, G)
    SetBlueByte  (X, Y, B)
  NEXT
NEXT
'**************************************************************
'                       End EmbossMore Filter
'**************************************************************
SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
DeleteDC (hMemDC)
DeleteDC (hDestDC)
DeleteDC (hDC)

GlobalFree ((HGLOBAL) gClone)
GlobalFree ((HGLOBAL) glpBits)
GlobalFree ((HGLOBAL) pbmi)
FUNCTION = hBmp
END FUNCTION








FUNCTION Diffuse OPTIONAL (bmpSource AS HBITMAP, Factor = 10) AS HBITMAP
'**************************************************
'      bmpSource is not modified
'**************************************************
DIM pbmi   AS PBITMAPINFO
DIM pbih     AS PBITMAPINFOHEADER
DIM hMemDC   AS HDC
DIM hDestDC  AS HDC
DIM hDC      AS HDC
DIM hBmp     AS HBITMAP
DIM bmp      AS BITMAP
DIM cClrBits AS WORD
DIM R,G,B
'***********************************************
gH = BCX_BMPHEIGHT(bmpSource)
gW = BCX_BMPWIDTH (bmpSource)

hMemDC = CreateCompatibleDC(NULL)
SelectObject(hMemDC, bmpSource)
hDestDC = CreateCompatibleDC(hMemDC)
hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
SelectObject(hDestDC,hBmp)
BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

SELECT CASE cClrBits
  CASE     1   : cClrBits =  1
  CASE <=  4   : cClrBits =  4
  CASE <=  8   : cClrBits =  8
  CASE <= 16   : cClrBits = 16
  CASE <= 24   : cClrBits = 24
  CASE ELSE    : cClrBits = 32
END SELECT

IF cClrBits < 24 THEN
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
ELSE
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
END IF

pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
pbmi->bmiHeader.biWidth    = bmp.bmWidth
pbmi->bmiHeader.biHeight   = bmp.bmHeight
pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

IF cClrBits < 24 THEN
  pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
ELSE
  pbmi->bmiHeader.biClrUsed = 0
END IF

pbmi->bmiHeader.biCompression = BI_RGB
pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
pbmi->bmiHeader.biClrImportant = 0

pbih = (PBITMAPINFOHEADER) pbmi
glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

IF NOT glpBits THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

hDC = CreateCompatibleDC (NULL)

IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

'**************************************************************
'                       Start Diffuse Filter
'**************************************************************

DIM aX AS Long, aY AS Long
DIM hF AS Long

REGISTER X
REGISTER Y

hF = Factor * 0.5

FOR Y = 0 TO gH
  FOR X = 0 TO gW

    aX = RND * Factor - hF
    aY = RND * Factor - hF

    IF X + aX < 1 THEN aX = 0
    IF X + aX > gW THEN aX = 0
    IF Y + aY < 1 THEN aY = 0
    IF Y + aY > gH THEN aY = 0

    SetRedByte(X, Y, GRB( X + aX, Y + aY))
    SetGreenByte(X, Y,GGB(X + aX, Y + aY))
    SetBlueByte(X, Y, GBB(X + aX, Y + aY))

  NEXT
NEXT

'**************************************************************
'                       End Diffuse Filter
'**************************************************************
SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
DeleteDC (hMemDC)
DeleteDC (hDestDC)
DeleteDC (hDC)

GlobalFree ((HGLOBAL) glpBits)
GlobalFree ((HGLOBAL) pbmi)
FUNCTION = hBmp
END FUNCTION







FUNCTION EngraveMore OPTIONAL (bmpSource AS HBITMAP, BackColor = 5921370)  AS HBITMAP
'************************************************************************
'      bmpSource is not modified
'************************************************************************
DIM pbmi   AS PBITMAPINFO
DIM pbih     AS PBITMAPINFOHEADER
DIM hMemDC   AS HDC
DIM hDestDC  AS HDC
DIM hDC      AS HDC
DIM hBmp     AS HBITMAP
DIM bmp      AS BITMAP
DIM cClrBits AS WORD
DIM R,G,B
'***********************************************
gH = BCX_BMPHEIGHT(bmpSource)
gW = BCX_BMPWIDTH (bmpSource)

hMemDC = CreateCompatibleDC(NULL)
SelectObject(hMemDC, bmpSource)
hDestDC = CreateCompatibleDC(hMemDC)
hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
SelectObject(hDestDC,hBmp)
BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

SELECT CASE cClrBits
  CASE     1   : cClrBits =  1
  CASE <=  4   : cClrBits =  4
  CASE <=  8   : cClrBits =  8
  CASE <= 16   : cClrBits = 16
  CASE <= 24   : cClrBits = 24
  CASE ELSE    : cClrBits = 32
END SELECT

IF cClrBits < 24 THEN
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
ELSE
  pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
END IF

pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
pbmi->bmiHeader.biWidth    = bmp.bmWidth
pbmi->bmiHeader.biHeight   = bmp.bmHeight
pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

IF cClrBits < 24 THEN
  pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
ELSE
  pbmi->bmiHeader.biClrUsed = 0
END IF

pbmi->bmiHeader.biCompression = BI_RGB
pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
pbmi->bmiHeader.biClrImportant = 0

pbih = (PBITMAPINFOHEADER) pbmi
glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

IF NOT glpBits THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

hDC = CreateCompatibleDC (NULL)

IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
  MSGBOX "Memory Problem ... aborting"
  END
  EXIT FUNCTION
END IF

'**************************************************************
'                       Start EngraveMore Filter
'**************************************************************
gClone = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)
GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,gClone, pbmi, DIB_RGB_COLORS)
'**************************************************************
DIM cB AS Long, cG AS Long, cR AS Long

REGISTER X
REGISTER Y

cR = GETRVALUE (BackColor)
cG = GETGVALUE (BackColor)
cB = GETBVALUE (BackColor)

FOR Y = 1 TO gH - 2
  FOR X = 1 TO gW - 2

    R = GCB(0, X + 1, Y - 1) - GCB(0, X - 1, Y - 1) + GCB(0, X + 1, Y) - GCB(0, X - 1, Y) + GCB(0, X + 1, Y + 1) - GCB(0, X - 1, Y + 1) + cR
    G = GCB(1, X + 1, Y - 1) - GCB(1, X - 1, Y - 1) + GCB(1, X + 1, Y) - GCB(1, X - 1, Y) + GCB(1, X + 1, Y + 1) - GCB(1, X - 1, Y + 1) + cG
    B = GCB(2, X + 1, Y - 1) - GCB(2, X - 1, Y - 1) + GCB(2, X + 1, Y) - GCB(2, X - 1, Y) + GCB(2, X + 1, Y + 1) - GCB(2, X - 1, Y + 1) + cB

    R = MIN(MAX(R, 0), 255)
    G = MIN(MAX(G, 0), 255)
    B = MIN(MAX(B, 0), 255)

    SetRedByte   (X, Y, R)
    SetGreenByte (X, Y, G)
    SetBlueByte  (X, Y, B)

  NEXT
NEXT

'**************************************************************
'                       End EngraveMore Filter
'**************************************************************
SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
DeleteDC (hMemDC)
DeleteDC (hDestDC)
DeleteDC (hDC)

GlobalFree ((HGLOBAL) gClone)
GlobalFree ((HGLOBAL) glpBits)
GlobalFree ((HGLOBAL) pbmi)
FUNCTION = hBmp
END FUNCTION









FUNCTION Relief (bmpSource AS HBITMAP) AS HBITMAP
'************************************************************************
'      bmpSource is not modified
'************************************************************************
  DIM pbmi   AS PBITMAPINFO
  DIM pbih     AS PBITMAPINFOHEADER
  DIM hMemDC   AS HDC
  DIM hDestDC  AS HDC
  DIM hDC      AS HDC
  DIM hBmp     AS HBITMAP
  DIM bmp      AS BITMAP
  DIM cClrBits AS WORD
  DIM R,G,B
'***********************************************
  gH = BCX_BMPHEIGHT(bmpSource)
  gW = BCX_BMPWIDTH (bmpSource)

  hMemDC = CreateCompatibleDC(NULL)
  SelectObject(hMemDC, bmpSource)
  hDestDC = CreateCompatibleDC(hMemDC)
  hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
  SelectObject(hDestDC,hBmp)
  BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

  IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

  SELECT CASE cClrBits
    CASE     1   : cClrBits =  1
    CASE <=  4   : cClrBits =  4
    CASE <=  8   : cClrBits =  8
    CASE <= 16   : cClrBits = 16
    CASE <= 24   : cClrBits = 24
    CASE ELSE    : cClrBits = 32
  END SELECT

  IF cClrBits < 24 THEN
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
  ELSE
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
  END IF

  pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
  pbmi->bmiHeader.biWidth    = bmp.bmWidth
  pbmi->bmiHeader.biHeight   = bmp.bmHeight
  pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
  pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

  IF cClrBits < 24 THEN
    pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
  ELSE
    pbmi->bmiHeader.biClrUsed = 0
  END IF

  pbmi->bmiHeader.biCompression = BI_RGB
  pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
  pbmi->bmiHeader.biClrImportant = 0

  pbih = (PBITMAPINFOHEADER) pbmi
  glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

  IF NOT glpBits THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  hDC = CreateCompatibleDC (NULL)

  IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

'**************************************************************
'                       Start Relief Filter
'**************************************************************
  gClone = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)
  GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,gClone, pbmi, DIB_RGB_COLORS)
'**************************************************************
  REGISTER X
  REGISTER Y

  FOR Y = 1 TO gH - 2
    FOR X = 1 TO gW - 2

      R = 2 * GCB(0, X - 1, Y - 1) + GCB(0, X - 1, Y) +  GCB(0, X, Y - 1) - GCB(0, X, Y + 1) - GCB(0, X + 1, Y) - 2 * GCB(0, X + 1, Y + 1)
      G = 2 * GCB(1, X - 1, Y - 1) + GCB(1, X - 1, Y) +  GCB(1, X, Y - 1) - GCB(1, X, Y + 1) - GCB(1, X + 1, Y) - 2 * GCB(1, X + 1, Y + 1)
      B = 2 * GCB(2, X - 1, Y - 1) + GCB(2, X - 1, Y) +  GCB(2, X, Y - 1) - GCB(2, X, Y + 1) - GCB(2, X + 1, Y) - 2 * GCB(2, X + 1, Y + 1)

      R = (GCB(0, X, Y) + R) * 0.5 + 50
      G = (GCB(1, X, Y) + G) * 0.5 + 50
      B = (GCB(2, X, Y) + B) * 0.5 + 50

      R = MIN(MAX(R, 0), 255)
      G = MIN(MAX(G, 0), 255)
      B = MIN(MAX(B, 0), 255)

      SetAnyByte(0, X, Y, R)
      SetAnyByte(1, X, Y, G)
      SetAnyByte(2, X, Y, B)

    NEXT
  NEXT

'**************************************************************
'                       End Relief Filter
'**************************************************************
  SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
  DeleteDC (hMemDC)
  DeleteDC (hDestDC)
  DeleteDC (hDC)

  GlobalFree ((HGLOBAL) gClone)
  GlobalFree ((HGLOBAL) glpBits)
  GlobalFree ((HGLOBAL) pbmi)

  FUNCTION = hBmp
END FUNCTION












FUNCTION EnhancedDiffusionBW (bmpSource AS HBITMAP) AS HBITMAP
'************************************************************************
'      bmpSource is not modified
'************************************************************************
  DIM pbmi   AS PBITMAPINFO
  DIM pbih     AS PBITMAPINFOHEADER
  DIM hMemDC   AS HDC
  DIM hDestDC  AS HDC
  DIM hDC      AS HDC
  DIM hBmp     AS HBITMAP
  DIM bmp      AS BITMAP
  DIM cClrBits AS WORD
  DIM R,G,B
'***********************************************
  gH = BCX_BMPHEIGHT(bmpSource)
  gW = BCX_BMPWIDTH (bmpSource)

  hMemDC = CreateCompatibleDC(NULL)
  SelectObject(hMemDC, bmpSource)
  hDestDC = CreateCompatibleDC(hMemDC)
  hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
  SelectObject(hDestDC,hBmp)
  BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

  IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

  SELECT CASE cClrBits
    CASE     1   : cClrBits =  1
    CASE <=  4   : cClrBits =  4
    CASE <=  8   : cClrBits =  8
    CASE <= 16   : cClrBits = 16
    CASE <= 24   : cClrBits = 24
    CASE ELSE    : cClrBits = 32
  END SELECT

  IF cClrBits < 24 THEN
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
  ELSE
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
  END IF

  pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
  pbmi->bmiHeader.biWidth    = bmp.bmWidth
  pbmi->bmiHeader.biHeight   = bmp.bmHeight
  pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
  pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

  IF cClrBits < 24 THEN
    pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
  ELSE
    pbmi->bmiHeader.biClrUsed = 0
  END IF

  pbmi->bmiHeader.biCompression = BI_RGB
  pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
  pbmi->bmiHeader.biClrImportant = 0

  pbih = (PBITMAPINFOHEADER) pbmi
  glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

  IF NOT glpBits THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  hDC = CreateCompatibleDC (NULL)

  IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

'**************************************************************
'                       Start EnhancedDiffusionBW Filter
'**************************************************************
  gClone = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)
  GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,gClone, pbmi, DIB_RGB_COLORS)
'**************************************************************
  DIM Erro AS Long, nCol AS Long
  DIM mCol AS Long
  DIM Speed![766]

  REGISTER X
  REGISTER Y

  FOR X = 0 TO 765
    Speed[X] = X *.333
  NEXT X

  mCol = 0
  nCol = 0

  FOR Y = 1 TO gH-2
    FOR X = 1 TO gW-2
      B = GCB(1, X, Y)
      G = GCB(2, X, Y)
      R = GCB(3, X, Y)
      B = Speed[R + G + B]
      mCol = mCol + B
      nCol = nCol + 1.0
    NEXT
  NEXT

  mCol = mCol / nCol + 0.001

  FOR Y = 1 TO gH-2
    FOR X = 1 TO gW-2

      IF (X > 1) AND (Y > 1) AND (X < gW) AND (Y < gH) THEN

        B = GCB(1, X - 1, Y - 1) + GCB(1, X - 1, Y) + _
        GCB(1, X - 1, Y + 1) + GCB(1, X, Y - 1) + _
        GCB(1, X, Y + 1) + GCB(1, X + 1, Y - 1) + _
        GCB(1, X + 1, Y) + GCB(1, X + 1, Y + 1)

        G = GCB(2, X - 1, Y - 1) + GCB(2, X - 1, Y) + _
        GCB(2, X - 1, Y + 1) + GCB(2, X, Y - 1) + _
        GCB(2, X, Y + 1) + GCB(2, X + 1, Y - 1) + _
        GCB(2, X + 1, Y) + GCB(2, X + 1, Y + 1)

        R = GCB(3, X - 1, Y - 1) + GCB(3, X - 1, Y) + _
        GCB(3, X - 1, Y + 1) + GCB(3, X, Y - 1) + _
        GCB(3, X, Y + 1) + GCB(3, X + 1, Y - 1) + _
        GCB(3, X + 1, Y) + GCB(3, X + 1, Y + 1)

        B = (10 * GCB(1, X, Y) - B) / 2
        G = (10 * GCB(2, X, Y) - G) / 2
        R = (10 * GCB(3, X, Y) - R) / 2

        R = MIN(MAX(R, 0), 255)
        G = MIN(MAX(G, 0), 255)
        B = MIN(MAX(B, 0), 255)
      ELSE
        B = GCB(1, X, Y)
        G = GCB(2, X, Y)
        R = GCB(3, X, Y)
      END IF

      B = Speed[R + G + B]
      B = B + Erro

      IF B < 0 THEN B = 0
      IF B > 255 THEN B = 255
      IF B < mCol THEN nCol = 0 ELSE nCol = 255

      Erro = (B - nCol) *0.25

      SetAnyByte(0, X, Y, nCol)
      SetAnyByte(1, X, Y, nCol)
      SetAnyByte(2, X, Y, nCol)

    NEXT
  NEXT

'**************************************************************
'                       End EnhancedDiffusionBW Filter
'**************************************************************
  SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
  DeleteDC (hMemDC)
  DeleteDC (hDestDC)
  DeleteDC (hDC)

  GlobalFree ((HGLOBAL) gClone)
  GlobalFree ((HGLOBAL) glpBits)
  GlobalFree ((HGLOBAL) pbmi)

  FUNCTION = hBmp
END FUNCTION







FUNCTION Dilate (bmpSource AS HBITMAP) AS HBITMAP
'************************************************************************
'      bmpSource is not modified
'************************************************************************
  DIM pbmi   AS PBITMAPINFO
  DIM pbih     AS PBITMAPINFOHEADER
  DIM hMemDC   AS HDC
  DIM hDestDC  AS HDC
  DIM hDC      AS HDC
  DIM hBmp     AS HBITMAP
  DIM bmp      AS BITMAP
  DIM cClrBits AS WORD
  DIM R,G,B
'***********************************************
  gH = BCX_BMPHEIGHT(bmpSource)
  gW = BCX_BMPWIDTH (bmpSource)

  hMemDC = CreateCompatibleDC(NULL)
  SelectObject(hMemDC, bmpSource)
  hDestDC = CreateCompatibleDC(hMemDC)
  hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
  SelectObject(hDestDC,hBmp)
  BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

  IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

  SELECT CASE cClrBits
    CASE     1   : cClrBits =  1
    CASE <=  4   : cClrBits =  4
    CASE <=  8   : cClrBits =  8
    CASE <= 16   : cClrBits = 16
    CASE <= 24   : cClrBits = 24
    CASE ELSE    : cClrBits = 32
  END SELECT

  IF cClrBits < 24 THEN
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
  ELSE
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
  END IF

  pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
  pbmi->bmiHeader.biWidth    = bmp.bmWidth
  pbmi->bmiHeader.biHeight   = bmp.bmHeight
  pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
  pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

  IF cClrBits < 24 THEN
    pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
  ELSE
    pbmi->bmiHeader.biClrUsed = 0
  END IF

  pbmi->bmiHeader.biCompression = BI_RGB
  pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
  pbmi->bmiHeader.biClrImportant = 0

  pbih = (PBITMAPINFOHEADER) pbmi
  glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

  IF NOT glpBits THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  hDC = CreateCompatibleDC (NULL)

  IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

'**************************************************************
'                       Start Dilate Filter
'**************************************************************
  gClone = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)
  GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,gClone, pbmi, DIB_RGB_COLORS)
'**************************************************************

  DIM V AS Long
  DIM vMax AS Long

  REGISTER X
  REGISTER Y
  REGISTER I

  FOR Y = 1 TO gH - 2
    FOR X = 1 TO gW - 2
      FOR I = 0 TO 2
        vMax = 0
        V = GCB(I, X - 1, Y - 1)
        IF V > vMax THEN vMax = V
        V = GCB(I, X, Y - 1)
        IF V > vMax THEN vMax = V
        V = GCB(I, X + 1, Y - 1)
        IF V > vMax THEN vMax = V

        V = GCB(I, X - 1, Y)
        IF V > vMax THEN vMax = V
        V = GCB(I, X, Y)
        IF V > vMax THEN vMax = V
        V = GCB(I, X + 1, Y)
        IF V > vMax THEN vMax = V

        V = GCB(I, X - 1, Y + 1)
        IF V > vMax THEN vMax = V
        V = GCB(I, X, Y + 1)
        IF V > vMax THEN vMax = V
        V = GCB(I, X + 1, Y + 1)
        IF V > vMax THEN vMax = V

        R = MIN(MAX(R, 0), 255)
        G = MIN(MAX(G, 0), 255)
        B = MIN(MAX(B, 0), 255)

        SetAnyByte(I, X, Y, vMax)
      NEXT
    NEXT
  NEXT

'**************************************************************
'                       End Dilate Filter
'**************************************************************
  SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
  DeleteDC (hMemDC)
  DeleteDC (hDestDC)
  DeleteDC (hDC)

  GlobalFree ((HGLOBAL) gClone)
  GlobalFree ((HGLOBAL) glpBits)
  GlobalFree ((HGLOBAL) pbmi)

  FUNCTION = hBmp
END FUNCTION











FUNCTION Erode (bmpSource AS HBITMAP) AS HBITMAP
'************************************************************************
'      bmpSource is not modified
'************************************************************************
  DIM pbmi   AS PBITMAPINFO
  DIM pbih     AS PBITMAPINFOHEADER
  DIM hMemDC   AS HDC
  DIM hDestDC  AS HDC
  DIM hDC      AS HDC
  DIM hBmp     AS HBITMAP
  DIM bmp      AS BITMAP
  DIM cClrBits AS WORD
  DIM R,G,B
'***********************************************
  gH = BCX_BMPHEIGHT(bmpSource)
  gW = BCX_BMPWIDTH (bmpSource)

  hMemDC = CreateCompatibleDC(NULL)
  SelectObject(hMemDC, bmpSource)
  hDestDC = CreateCompatibleDC(hMemDC)
  hBmp= CreateCompatibleBitmap (hMemDC,gW,gH)
  SelectObject(hDestDC,hBmp)
  BitBlt (hDestDC,0,0,gW,gH,hMemDC,0,0,SRCCOPY)
'***********************************************

  IF NOT GetObject (hBmp,SIZEOF (BITMAP),(LPSTR) &bmp) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  cClrBits = (WORD) (bmp.bmPlanes * bmp.bmBitsPixel)

  SELECT CASE cClrBits
    CASE     1   : cClrBits =  1
    CASE <=  4   : cClrBits =  4
    CASE <=  8   : cClrBits =  8
    CASE <= 16   : cClrBits = 16
    CASE <= 24   : cClrBits = 24
    CASE ELSE    : cClrBits = 32
  END SELECT

  IF cClrBits < 24 THEN
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER) + SIZEOF (RGBQUAD) *(1 << cClrBits))
  ELSE
    pbmi = (PBITMAPINFO) GlobalAlloc (LPTR, SIZEOF(BITMAPINFOHEADER))
  END IF

  pbmi->bmiHeader.biSize     = SIZEOF (BITMAPINFOHEADER)
  pbmi->bmiHeader.biWidth    = bmp.bmWidth
  pbmi->bmiHeader.biHeight   = bmp.bmHeight
  pbmi->bmiHeader.biPlanes   = bmp.bmPlanes
  pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel

  IF cClrBits < 24 THEN
    pbmi->bmiHeader.biClrUsed = (WORD)(1 << cClrBits)
  ELSE
    pbmi->bmiHeader.biClrUsed = 0
  END IF

  pbmi->bmiHeader.biCompression = BI_RGB
  pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) / 8 * pbmi->bmiHeader.biHeight * cClrBits
  pbmi->bmiHeader.biClrImportant = 0

  pbih = (PBITMAPINFOHEADER) pbmi
  glpBits = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)

  IF NOT glpBits THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

  hDC = CreateCompatibleDC (NULL)

  IF NOT GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,glpBits, pbmi, DIB_RGB_COLORS) THEN
    MSGBOX "Memory Problem ... aborting"
    END
    EXIT FUNCTION
  END IF

'**************************************************************
'                       Start Erode Filter
'**************************************************************
  gClone = (LPBYTE) GlobalAlloc (GMEM_FIXED, pbih->biSizeImage)
  GetDIBits (hDC, hBmp,0,(WORD)pbih->biHeight,gClone, pbmi, DIB_RGB_COLORS)
'**************************************************************
  DIM V AS Long
  DIM vMin AS Long

  REGISTER X
  REGISTER Y
  REGISTER I

  FOR Y = 1 TO gH - 2
    FOR X = 1 TO gW - 2
      FOR I = 0 TO 2
        vMin = 255
        V = GCB(I, X - 1, Y - 1)
        IF V < vMin THEN vMin = V
        V = GCB(I, X, Y - 1)
        IF V < vMin THEN vMin = V
        V = GCB(I, X + 1, Y - 1)
        IF V < vMin THEN vMin = V

        V = GCB(I, X - 1, Y)
        IF V < vMin THEN vMin = V
        V = GCB(I, X, Y)
        IF V < vMin THEN vMin = V
        V = GCB(I, X + 1, Y)
        IF V < vMin THEN vMin = V

        V = GCB(I, X - 1, Y + 1)
        IF V < vMin THEN vMin = V
        V = GCB(I, X, Y + 1)
        IF V < vMin THEN vMin = V
        V = GCB(I, X + 1, Y + 1)
        IF V < vMin THEN vMin = V

        R = MIN(MAX(R, 0), 255)
        G = MIN(MAX(G, 0), 255)
        B = MIN(MAX(B, 0), 255)

        SetAnyByte(I, X, Y,vMin)
      NEXT
    NEXT
  NEXT

'**************************************************************
'                       End Erode Filter
'**************************************************************
  SetDIBits (hDC, hBmp, 0, (WORD) pbih->biHeight, glpBits, pbmi, DIB_RGB_COLORS)
  DeleteDC (hMemDC)
  DeleteDC (hDestDC)
  DeleteDC (hDC)

  GlobalFree ((HGLOBAL) gClone)
  GlobalFree ((HGLOBAL) glpBits)
  GlobalFree ((HGLOBAL) pbmi)

  FUNCTION = hBmp
END FUNCTION




'***********************************************************************************
FUNCTION OvalFrame OPTIONAL (BmpSource AS HBITMAP, FrameColor=16777215) AS HBITMAP
'***********************************************************************************
DIM RAW hMemDC AS HDC
DIM RAW hDestDC AS HDC
DIM RAW bmpNew AS HBITMAP
DIM RAW H = BCX_BMPHEIGHT(BmpSource)
DIM RAW W = BCX_BMPWIDTH(BmpSource)

hMemDC = CreateCompatibleDC(NULL)
SelectObject(hMemDC, BmpSource)
hDestDC = CreateCompatibleDC(hMemDC)
bmpNew  = CreateCompatibleBitmap(hMemDC,W,H)
SelectObject(hDestDC,bmpNew)
BitBlt (hDestDC,0,0,W,H,hMemDC,0,0,SRCCOPY)

BCX_ELLIPSE(0,W*0.005,H*0.005,W-(W*0.005),H-(H*0.005),RGB(0,255,0),0,hDestDC)
BCX_ELLIPSE(0,W*0.004,H*0.004,W-(W*0.004),H-(H*0.004),RGB(0,255,0),0,hDestDC)

BCX_FLOODFILL(0,0,0,RGB(0,255,0),FrameColor,hDestDC)

BCX_ELLIPSE(0,W*0.005,H*0.005,W-(W*0.005),H-(H*0.005),RGB(255,255,255),0,hDestDC)
BCX_ELLIPSE(0,W*0.004,H*0.004,W-(W*0.004),H-(H*0.004),RGB(255,255,255),0,hDestDC)

DeleteDC (hMemDC)
DeleteDC (hDestDC)
FUNCTION = bmpNew
END FUNCTION






FUNCTION Shape OPTIONAL (SrcBmp AS HBITMAP, ShapeBm AS HBITMAP, Mask = 65280) AS HBITMAP
DIM RAW hMemDC_A AS HDC
DIM RAW hMemDC_B AS HDC
DIM RAW hDestDC AS HDC
DIM RAW bmpNew AS HBITMAP
DIM RAW HA = BCX_BMPHEIGHT(SrcBmp)
DIM RAW WA = BCX_BMPWIDTH(SrcBmp)
DIM RAW HB = BCX_BMPHEIGHT(ShapeBm)
DIM RAW WB = BCX_BMPWIDTH(ShapeBm)
hMemDC_A = CreateCompatibleDC(NULL)
SelectObject(hMemDC_A, SrcBmp)
hMemDC_B = CreateCompatibleDC(NULL)
SelectObject(hMemDC_B, ShapeBm)
hDestDC = CreateCompatibleDC(hMemDC_A)
bmpNew  = CreateCompatibleBitmap(hMemDC_A,WA,HA)
SelectObject(hDestDC,bmpNew)
BitBlt (hDestDC,0,0,WA,HA,hMemDC_A,0,0,SRCCOPY)
TransparentBlt(LIB "msimg32.dll", hDestDC, 0, 0, WA, HA, hMemDC_B, 0, 0, WB, HB, Mask)
DeleteDC (hMemDC_A)
DeleteDC (hMemDC_B)
DeleteDC (hDestDC)
FUNCTION = bmpNew
END FUNCTION










FUNCTION Gradient (W,H,TopRGB, BotRGB) AS HBITMAP
  DIM RAW hMemDC  AS HDC
  DIM RAW hDestDC AS HDC
  DIM RAW WinDC   AS HDC
  DIM RAW rFill   AS RECT
  DIM RAW fStep   AS SINGLE
  DIM RAW hBrush  AS HBRUSH
  DIM RAW Strip   AS INTEGER
  DIM RAW bmpNew  AS HBITMAP
'***************************************************
  hMemDC = CreateCompatibleDC(NULL)
'***************************************************
  WinDC = GetDC(NULL)
  bmpNew = CreateCompatibleBitmap(WinDC, W, H)
  ReleaseDC(NULL, WinDC)
'***************************************************
  SelectObject(hMemDC, bmpNew)
  hDestDC = CreateCompatibleDC(hMemDC)
  bmpNew  = CreateCompatibleBitmap(hMemDC,W,H)
  SelectObject(hDestDC,bmpNew)
  fStep = H / 256.0
  FOR Strip = 0 TO 255
    SetRect (&rFill,0,Strip*fStep,W,(Strip+1)*fStep)
    hBrush = CreateSolidBrush(RGB(0, 0, 255-Strip))
    FillRect (hDestDC, &rFill, hBrush)
    DeleteObject (hBrush)
  NEXT
  DeleteDC (hMemDC)
  DeleteDC (hDestDC)
  FUNCTION = bmpNew
END FUNCTION










FUNCTION RotateBmp(hBitmap AS HBITMAP, Angle AS SINGLE, clrBack AS COLORREF) AS HBITMAP
'*****************************************************************************************
' Original MFC code by Zafir Anjum August 5, 1998
' http://www.codeguru.com/cpp/g-m/bitmap/specialeffects/article.php/c1743/
' Converted to BCX by Kevin Diggins with help by Mike Henning
' Specify rotation angle using decimal degrees instead of radians
'*****************************************************************************************
  
  DIM sourceDC AS HDC   
  DIM destDC   AS HDC

  sourceDC = CreateCompatibleDC(NULL) 
  destDC   = CreateCompatibleDC(NULL)

  
  DIM bm AS BITMAP
  GetObject(hBitmap, SIZEOF(bm),&bm)   ' Get logical coordinates

  DIM cosine AS SINGLE
  DIM sine   AS SINGLE

  cosine = COS(Angle * 0.017453)
  sine   = SIN(Angle * 0.017453)

  ' Compute dimensions of the resulting bitmap
  ' First get the coordinates of the 3 corners other than origin

  DIM RAW x1 = (bm.bmHeight * sine)
  DIM RAW y1 = (bm.bmHeight * cosine)
  DIM RAW x2 = (bm.bmWidth * cosine + bm.bmHeight * sine)
  DIM RAW y2 = (bm.bmHeight * cosine - bm.bmWidth * sine)
  DIM RAW x3 = (bm.bmWidth * cosine)
  DIM RAW y3 = (-bm.bmWidth * sine)

  DIM RAW minx = MIN(0,MIN(x1, MIN(x2,x3)))
  DIM RAW miny = MIN(0,MIN(y1, MIN(y2,y3)))
  DIM RAW maxx = MAX(0,MAX(x1, MAX(x2,x3)))
  DIM RAW maxy = MAX(0,MAX(y1, MAX(y2,y3)))

  DIM RAW w = 1 + maxx - minx
  DIM RAW h = 1 + maxy - miny

  '*************************************
  ' Create a bitmap to hold the result
  '*************************************

  DIM RAW WinDC AS HDC
  DIM RAW hbmResult AS HBITMAP
  WinDC = GetDC(NULL)
  hbmResult = CreateCompatibleBitmap(WinDC, w, h)
  ReleaseDC(NULL, WinDC)

  DIM RAW hbmOldSource AS HBITMAP
  DIM RAW hbmOldDest AS HBITMAP

  hbmOldSource = SelectObject(sourceDC, hBitmap)
  hbmOldDest = SelectObject(destDC, hbmResult)

  ' Draw the background color before we change mapping mode

  DIM RAW hbrBack AS HBRUSH
  DIM RAW hbrOld  AS HBRUSH

  hbrBack = CreateSolidBrush(clrBack)
  hbrOld = SelectObject(destDC, hbrBack)

  PatBlt(destDC,0, 0, w, h, PATCOPY)

  DeleteObject(SelectObject(destDC, hbrOld))

  ' use world transform to rotate the bitmap

  SetGraphicsMode(destDC, GM_ADVANCED)

  DIM xform AS XFORM

  xform.eM11 = cosine
  xform.eM12 = -sine
  xform.eM21 = sine
  xform.eM22 = cosine
  xform.eDx = -minx
  xform.eDy = -miny

  SetWorldTransform(destDC, &xform)

  '  Now do the actual rotating - a pixel at a time

  BitBlt(destDC,0,0,bm.bmWidth, bm.bmHeight, sourceDC, 0, 0, SRCCOPY )

  ' Restore DCs
  SelectObject(sourceDC, hbmOldSource)
  SelectObject(destDC, hbmOldDest)

  FUNCTION = hbmResult
END FUNCTION











FUNCTION MirrorBmp OPTIONAL (hBitmap AS HBITMAP, FlipType = 1) AS HBITMAP
'*****************************************************************************************
' Original MFC code by Zafir Anjum August 5, 1998
' http://www.codeguru.com/cpp/g-m/bitmap/specialeffects/article.php/c1725/
' Converted to BCX by Kevin Diggins with help by Mike Henning
' FlipType: 1 = Flip Horizontal   0 = Flip Vertical 
'*****************************************************************************************
  DIM RAW sourceDC  AS HDC
  DIM RAW destDC    AS HDC
  DIM RAW WinDC     AS HDC
  DIM RAW hbmResult AS HBITMAP
  DIM RAW bm        AS BITMAP
  DIM hbmOldSource  AS HBITMAP
  DIM hbmOldDest    AS HBITMAP

  sourceDC = CreateCompatibleDC(NULL)
  destDC = CreateCompatibleDC(NULL)
  GetObject(hBitmap, sizeof(bm), &bm)

'*************************************
' Create a bitmap to hold the result
'*************************************

  WinDC = GetDC(NULL)
  hbmResult = CreateCompatibleBitmap(WinDC, bm.bmWidth, bm.bmHeight)
  ReleaseDC(NULL, WinDC)

  hbmOldSource = SelectObject(sourceDC, hBitmap)
  hbmOldDest = SelectObject(destDC, hbmResult)

  IF FlipType THEN
    StretchBlt( destDC, 0, 0, bm.bmWidth, bm.bmHeight, sourceDC, bm.bmWidth-1, 0, -bm.bmWidth, bm.bmHeight, SRCCOPY)
  ELSE
    StretchBlt(destDC,  0, 0, bm.bmWidth, bm.bmHeight, sourceDC, 0, bm.bmHeight-1, bm.bmWidth, -bm.bmHeight, SRCCOPY)
  END IF

  SelectObject(sourceDC, hbmOldSource)
  SelectObject(destDC, hbmOldDest)

  FUNCTION = hbmResult
END FUNCTION