Question1：

Input image:

First, the Sobel mask is used for gradient calculation to highlight the edges of the
input image.
A Sobel mask in X direction can be represented as:
 −1 0 1 
Gx =  −2 0 2
 −1 0 1 
A Sobel mask in Y direction can be represented as:
 −1 −2 −1
G y =  0 0 0 
 1 2 1 
The results of Sobel mask calculation in X direction and Y direction are shown
below.

Second, use Average Filter or Gaussian Filter to smooth the results of Sobel mask
calculation.
A 3x3 Average Filter mask can be represented as:
 1 1 1
Mask = 1 1 1
1
9
1 1 1
A Gaussian Filter mask can be represented as:
( x2 + y 2 )
−
Mask ( x, y ) = G ( x, y ) = e 2r2

Sampling : G[ x, y] = G[m, n]

Sum : s =  G[m, n]
Normalized : G[m, n] = G[m, n] / s
The smooth processing results of gradient image are shown below.

Then, calculate the Magnitude of gradient. The Magnitude of gradient calculation

formula is as follows:
M ( x, y) = mag (f ) = Gx2 + Gy2

Finally, calculate the subtraction between the input image and the Magnitude of
gradient to get the image. The result is as follows.

Use Brightness Transformation to get the output image. Brightness Transformation

can be represented as:
Basic : g[ x, y] = f [ x, y] + c
 Saturation Operation : g[ x, y] = S ( f [ x, y] + c)
Output image:

Source code:
byte[,] filter2D(byte[,]f,float[,]mask)
{

int M = mask.GetLength(0)/2;
int N = mask.GetLength(1)/2;

int w = f.GetLength(0);
int h = f.GetLength(1);

byte[,] g = new byte[w,h];

for (int y=0;y<h;y++)

for (int x=0;x<w;x++)
{
float s = 0;
for (int m=-M;m<=M;m++)
for (int n=-N;n<=N;n++)
{
int xm = x+m;
int yn = y+n;

if (xm<0) xm = 0;
if (xm>w-1) xm = w-1;

if (yn<0) yn = 0;
if (yn>h-1) yn = h-1;

s += f[xm,yn]*mask[M+m,N+n];
 }
g[x,y] = S(s);
}

return g;
}

byte[,] highpass2D(byte[,]f,float[,]mask)
{

int M = mask.GetLength(0)/2;
int N = mask.GetLength(1)/2;

int w = f.GetLength(0);
int h = f.GetLength(1);

byte[,] g = new byte[w,h];

for (int y=0;y<h;y++)

for (int x=0;x<w;x++)
{
float s = 0;
for (int m=-M;m<=M;m++)
for (int n=-N;n<=N;n++)
{
int xm = x+m;
int yn = y+n;

if (xm<0) xm = 0;
if (xm>w-1) xm = w-1;

if (yn<0) yn = 0;
if (yn>h-1) yn = h-1;

s += f[xm,yn]*mask[M+m,N+n];

}
g[x,y] = S(s+128);
}

return g;
}
byte S(double v)
{
if (v<0) return 0;
if (v>255) return 255;
return (byte)v;
}

float[,] sobelX()
{
float[,] mask = new float[3,3];

mask[0,0]=-1; mask[1,0]= 0; mask[2,0]= 1;

mask[0,1]=-2; mask[1,1]= 0; mask[2,1]= 2;
mask[0,2]=-1; mask[1,2]= 0; mask[2,2]= 1;

return mask;
}

float[,] sobelY()
{
float[,] mask = new float[3,3];

mask[0,0]=-1; mask[1,0]=-2; mask[2,0]=-1;

mask[0,1]= 0; mask[1,1]= 0; mask[2,1]= 0;
mask[0,2]= 1; mask[1,2]= 2; mask[2,2]= 1;

return mask;
}

byte[,] get_mag(byte[,] gx,byte[,]gy)

{
int w = gx.GetLength(0);
int h = gx.GetLength(1);

byte[,] mag = new byte[w,h];

for (int y=0;y<h;y++)

for (int x=0;x<w;x++)
{
int rx= gx[x,y]-128;
int ry= gy[x,y]-128;
 mag[x,y] = S(Sqrt(rx*rx+ry*ry));
}

return mag;

byte[,] gt(byte[,]f,double b,double k)

{
int w = f.GetLength(0);
int h = f.GetLength(1);

byte[,] g = new byte[w,h];

for (int y=0;y<h;y++)

for (int x=0;x<w;x++)
{
g[x,y] = S(k*(f[x,y]-128)+128+b);
}

return g;
}

byte[,] sub(byte[,]f1,byte[,]f2)
{
int w = f1.GetLength(0);
int h = f1.GetLength(1);

byte[,] g = new byte[w,h];

for (int y=0;y<h;y++)

for (int x=0;x<w;x++)
{
g[x,y] = S(f1[x,y]-f2[x,y]+128);
}

return g;
}
float[,] blur_MxN(int M,int N)
{
float[,] mask = new float[2*M+1,2*N+1];

for (int m=-M;m<=M;m++)

for (int n=-N;n<=N;n++)
mask[m+M,n+N] = 1.0f/((2*M+1)*(2*N+1));

return mask;
}

float[,] ablur_mask(int size_x,int size_y)

{
return blur_MxN(size_x/2,size_y/2);
}

float[,] gblur_mask(double r)
{

int M = (int)(3*r);
int N = M;

float[,] mask = new float[2*M+1,2*N+1];

for (int m=-M;m<=M;m++)

for (int n=-N;n<=N;n++)
mask[m+M,n+N] = (float)Exp(-(m*m+n*n)/(2*r*r));

float s = 0;

for (int m=-M;m<=M;m++)

for (int n=-N;n<=N;n++)
s += mask[m+M,n+N];

for (int m=-M;m<=M;m++)

for (int n=-N;n<=N;n++)
mask[m+M,n+N] /= s;

return mask;
}

void main()
{
 byte[,] f = LoadImg();
ShowImg("f",f);

byte[,] gx = highpass2D(f,sobelX());
byte[,] gy = highpass2D(f,sobelY());

ShowImg("sobel_x",gx);
ShowImg("sobel_y",gy);

//byte[,] gx_1 = filter2D(gx,ablur_mask(5,5));

//byte[,] gy_1 = filter2D(gy,ablur_mask(5,5));

byte[,] gx_1 = filter2D(gx,gblur_mask(1));

byte[,] gy_1 = filter2D(gy,gblur_mask(1));

ShowImg("gx_1",gx_1);
ShowImg("gy_1",gy_1);

ShowImg("mag",gt(sub(f,get_mag(gx_1,gy_1)),0,0.3));

Question 2:
Input color image:
 I think the mountain as the main body in this color image is not prominent enough,
and the color is too light. So I use gamma transformation to make it more artistic and
vivid.
The gamma transformation can be represented as:
s = cr 
Output color image:

By using the gamma transformation to process the color image, the shadow contrast
between the front and back of the mountain is more prominent, and the cloud is more
layered than before. What’s more, it also brings out the rainbow in the distance which
is hard to percept before.
Source code:
ARGB[,] GT(ARGB[,]f,byte[]tab)
{
int w = f.GetLength(0);
int h = f.GetLength(1);

ARGB[,] g = new ARGB[w,h];

for (int y=0;y<h;y++)

for (int x=0;x<w;x++)
{
g[x,y].R = tab[f[x,y].R];
g[x,y].G = tab[f[x,y].G];
g[x,y].B = tab[f[x,y].B];
}

return g;
}
ARGB[,] GT(ARGB[,]f,byte[]tab_r,byte[]tab_g,byte[]tab_b)
{
int w = f.GetLength(0);
int h = f.GetLength(1);

ARGB[,] g = new ARGB[w,h];

for (int y=0;y<h;y++)

for (int x=0;x<w;x++)
{
g[x,y].R = tab_r[f[x,y].R];
g[x,y].G = tab_g[f[x,y].G];
g[x,y].B = tab_b[f[x,y].B];
}

return g;
}

byte[] gamma_tab(double r)
{
byte[] tab = new byte[256];

for (int n=0;n<256;n++)

tab[n] = (byte)(Pow(n/255.0,r)*255);

return tab;
}

void main()
{
ARGB[,] f = LoadColorImg();
ShowImg("f",f);

ShowImg("g,r=4",GT(f,gamma_tab(4)));