**Advice neeeded**The current edge detection algorithm works, but is not perfect, as the detail is lost at larger distances. I used a hack to help that matters, the hack being amplifying the edge detection as the distance grows, but it also fades at some point and is hackish. And so I decided to resolve to maths and normalize the results somehow to get a consistent detail amount. Current algorithm works with default depth buffer space, which is non linear. The new algorithm works in linear space and is as follows:

[Note that Laplacian edge detection is in use]

1.Get 5 samples from the depth buffer: depthm, depthn, depths, depthw, depthe, where depthm is exactly where the processed fragment is, depthn is slightly to the top, depths is slightly to the bottom etc.

2.Calculate their real coordinates in camera space[as well as convert to linear].

3.Compare the side samples to the middle sample by substracting and then normalize each difference by dividing by difference in distance between two camera-space points and add all four results. This should in theory help with situation, where at large distances from the camera two fragments are very close on the screen but very far in camera space, which is fatal for linear depth testing.

where:

2.a convert the non linear depth to linear using an algorithm from

http://stackoverflow.com/questions/6652253/getting-the-true-z-value-from-the-depth-bufferexact code:

`uniform sampler2D depthBuffTex;`

uniform float zNear;

uniform float zFar;

varying vec2 vTexCoord;

void main(void)

{

float z_b = texture2D(depthBuffTex, vTexCoord).x;

float z_n = 2.0 * z_b - 1.0;

float z_e = 2.0 * zNear * zFar / (zFar + zNear - z_n * (zFar - zNear));

}

2.b convert the screen coordinates to be [tan a, tan b], where a is horizontal angle and b i vertical. There probably is a better terminology with some spherical coordinates but I don't know these yet.

2.c create a 3d vector ( converted screen coordinates, 1.0 ) and scale it by linear depth. I assume this is estimated camera space coordinates of the fragment. It looks like it.

3.a each difference is as follows: (depthm - sidedepth)/lenght( positionm - sideposition)

And I may have screwed something at any point. Code looks fine, but the algorithm may not be, as I made it up myself.

My code:

`float znear = 1.0;`

float zfar = 10000000000.0;

float depthm = texture2D(depth_tex, gl_TexCoord[0].xy + distort ).r;

depthm = 2.0 * zfar * znear / (zfar + znear - ( 2.0 * depthm - 1.0 ) * (zfar - znear) ); //convert to linear

vec2 scorm = (gl_TexCoord[0].xy + distort) -0.5; //conversion to desired coordinates space. This line returns value from range (-0.5,0.5)

scorm = scorm * 2.0 * 0.5; // normalize to (-1, 1) and multiply by tan FOV/2, and default fov is IIRC 60 degrees

scorm.x = scorm.x * 1.6; //1.6 is aspect ratio 16/10

vec3 posm = vec3( scorm, 1.0 );

posm = posm * depthm; //scale by linearized depth

float depthn = texture2D(depth_tex, gl_TexCoord[0].xy + distort + vec2( 0.002*0.625 , 0.0) ).r; //0.625 is aspect ratio 10/16

depthn = 2.0 * zfar * znear / (zfar + znear - ( 2.0 * depthn - 1.0 ) * (zfar - znear) );

vec2 scorn = (gl_TexCoord[0].xy + distort + vec2( 0.002*0.625, 0.0) ) -0.5;

scorn = scorn * 2.0 * 0.5;

scorn.x = scorn.x * 1.6;

vec3 posn = vec3( scorn, 1.0 );

posn = posn * depthn;

float depths = texture2D(depth_tex, gl_TexCoord[0].xy + distort - vec2( 0.002*0.625 , 0.0) ).r;

depths = 2.0 * zfar * znear / (zfar + znear - ( 2.0 * depths - 1.0 ) * (zfar - znear) );

vec2 scors = (gl_TexCoord[0].xy + distort - vec2( 0.002*0.625, 0.0) ) -0.5;

scors = scors * 2.0 * 0.5;

scors.x = scors.x * 1.6;

vec3 poss = vec3( scors, 1.0 );

poss = poss * depths;

float depthw = texture2D(depth_tex, gl_TexCoord[0].xy + distort + vec2(0.0 , 0.002) ).r;

depthw = 2.0 * zfar * znear / (zfar + znear - ( 2.0 * depthw - 1.0 ) * (zfar - znear) );

vec2 scorw = ( gl_TexCoord[0].xy + distort + vec2( 0.0 , 0.002) ) -0.5;

scorw = scorw * 2.0 * 0.5;

scorw.x = scorw.x * 1.6;

vec3 posw = vec3( scorw, 1.0 );

posw = posw * depthw;

float depthe = texture2D(depth_tex, gl_TexCoord[0].xy + distort - vec2(0.0 , 0.002) ).r;

depthe = 2.0 * zfar * znear / (zfar + znear - ( 2.0 * depthe - 1.0 ) * (zfar - znear) );

vec2 score = ( gl_TexCoord[0].xy + distort - vec2( 0.0 , 0.002) ) -0.5;

score = score * 2.0 * 0.5;

score.x = score.x * 1.6;

vec3 pose = vec3( score, 1.0 );

pose = pose * depthe;

float Contour = ( depthn - depthm )/length(posm - posn) + ( depths - depthm )/length(posm - poss) + ( depthw - depthm )/length(posm - posw) + ( depthe - depthm )/length(posm - pose);

Contour = 0.25 * Contour;

color_out.rgb = vec3( Contour, Contour, Contour );

color_out.a = 1.0;

gl_FragColor = color_out;

Results are as follows:

In other words, it doesn't detect the silhouette and it shows some heavy artifacts. As well as it detects some things it shouldn't. This may be due to the fact that I need to type things like fov by hand, so the values may not be correct, but it doesn't mean the algorithm itself is correct. In the end, it may be just the nature of discrete depth buffer.

**Any thoughts?**