Guía: Como mejorar la imagen por software y hardware

Bueno bueno bueno...

Este tema es un poco peliagudo y seguro que crea opiniones de todos los tipos.

La intención es aprovechar al 100% las posibilidades que ofrecen los nuevos proyectores dlp. En mi caso concreto el benq w1070 pero sirve para cualquier equipo de optoma hd25, acer o el fabricante que sea.

Vale. Voy a obviar la calibración por sonda por dos motivos, por que no tengo una y por que los métodos que voy a describir aquí son totalmente compatibles con la calibración. Es más, de estar calibrados con sonda el resultado ha de ser más WOW si cabe.

Cuando digo mejorar por Software me refiero a reproducir contenido desde un ordenador. Que dispone de infinitos reproductores con muchas opciones diferentes.

Concretamente voy a explicar como conseguir emular los resultados del famoso DARBEE.

Para el que no lo sepa Darbee es un aparato que se pone entre el proyector y la fuente y es capaz de conseguir estos resultados con cualquier fuente.



Esta es su web: Home DarbeeVision

Pues bien, se puede hacer lo mismo con un ordenador, pero ha de ser potentillo por que necesita aplicar filtros en tiempo real.

La respuesta es: Daumn Pot Player - PotPlayer 1.5.40688 / 1.5.43968 Beta - VideoHelp.com Downloads


Mirar que se puede hacer con este bicho, entre muuuuchas otras cosas.

SIN FILTROS. Death Race 3 720p MKV (las fotos son de mala calidad pero sobran para ver el resultado.)



CON FILTROS.



Estas dos son aporte de Hemiutut.

Sin Filtro:



Con 3 Pixels Shaders.
1.-YV12 Chroma Upsampling.txt
2.-Sharpen.txt
3.-Sharpen_3x3.txt





Incredibol verdad?? no es un truco no. Es el Pot player. No voy a comentar todos los filtros que trae por que no acabaría. También se pueden aplicar unos encima de otros y conseguir negros más profundos como por ejemplo con el filtro "0-255 to 16-255" Si quieres hasta la puedes poner un filtro de "negativo" pero no tiene mucha gracia...

No voy a comentar sobre las opciones de audio que trae, por que también son muy extensas y no es mi objetivo.

Bueno... la segunda parte es más controvertida.

Mejorar por Hardware. Ya he citado a darbee, que es brutal y encima se aplica a todas las fuentes. Pero hay un tema muy importante. Como ya sabéis, son las pantallas.

Ayer buceando por foros me encontré con esto:



Son pantallas que probaron con un sony 4k de última generación con 1700L de potencia. Y entonces se me encendió la luz.

Si para 1700L ponen esas pantallas tan grises que pasaría si se la pongo yo al mio de 2000L (vale, menor contraste también)

Cabe recordar que uno de los puntos flojos de las maquinitas dlp son los negros, pero claro, nuestras pantallas son blancas. (La mía es gris, pero muy muy clarita)

Así que al llegar a casa hice unas simples pruebas. Poner cartulinas negras en una esquina y en otra blancas.







Bien, negras sí. No tenia grises, hoy haré las pruebas pertinentes. Si os fijáis abajo a la derecha hay un cuadro blanco que se diferencia bien poco de mi gris. Y como es lógico el negro se come los colores.

Yo saco una conclusión, y es que si doy en el clavo con la tonalidad gris los negros de este cacharro serán de notable alto manteniendo los colores vibrantes y potentes.

Me parece que la tonalidad será parecida a la pantalla de la foto.

Os seguiré informando, un saludo!


Edito: si el titulo dice que es para mejorar la imagen en los Dlp modernos es por la cantidad de lumens que traen. Por ejemplo una pantalla gris en un proyector de 1000lumens estropeara el contraste y se pierde mas de lo que se gana. Igualmente algunas de las tecnologias que se comentan en este post si que son compatibles con todos los proyectores. Si tienes un proyector lcd, dila, o lo que sea, con mas de 2000l las pantallas grises cobran sentido. :-)

Actualización:

Bien, ayer cartulina gris en mano. Sensaciones buenas y malas. Pero creo que vamos por el buen camino.

Os dejo una batería de fotos. Son con los ajustes de fabrica en la mayoría de los casos en modo estándar. O como mucho con la gamma subida un punto. Intentaré separar las que hice con luz y sin luz para que veáis.

(Como siempre tener en cuenta que las fotos son con smartphone y comprimidas por google+. Pero os puedo asegurar que, por lo menos lo que es el negro, permite hacerse una idea bastante exacta de lo que ocurre.)

Vamos allá. Fotos sin luz:





































Fotos con luz: (un ojo de buey y el flash directo a la pantalla)







Fotos 3D sin luz:















Las mejoras en negros es evidente. Ahora son negros absolutos. El problema radica en los blancos, que se ven grisáceos.
Cabe destacar que las imágenes ganan mucho en profundidad aunque pierden "punch" en los colores.

Creo que, en el caso de mi sala, con un gris un punto más claro se conseguirán negros muy decentes sin perder el blanco natural.

Ahí lo dejo, que os parece?

Otro metodo por Hardware para conseguir el mismo efecto que teniendo una pantalla gris es poner un filtro de fotografia ND. 1,2 o 3. Nuestro compañero acting comenta que los resultados de poner un filtro ND2 o hacer la pantalla gris han de ser los mismos con la ventaja que en 3D puedes quitar el filtro y no perder luminosidad.

Seria genial que algun poseedor de un filtro de estos nos dejara alguna foto.

Un saludo

Actualización 14-3-14

Siguiendo con mi búsqueda incansable y después de haber pasado buenos ratos con el Avisynth (Muy potente por cierto, pero tragón de CPU que lo hace inviable) parece que he encontrado la madre del cordero en esto de mejorar la nitidez y la profundidad por software.

Mi infructuosa búsqueda con el avisynth me llevó a plantearme algo: Ha de existir una código parecido pero que tire por GPU tal y como hacen los shaders del port player, MPC, o kmplayer.

Y ya te digo que si existe! Concretamente se llama LUMA SHARPEN y es creación del crack: Christian Cann Schuldt Jensen ~ CeeJay.dk

Básicamente hace un sharpen del Luma y luego una desviación del luma con varias pasadas. Una cosa rara que no entiendo mucho pero que es realmente efectiva. Es lo más parecido al Darbee que he podido conseguir. Lejos quedan los días del los sharpen 5x5, sharpen complex y compañía. ESTO SI ES UN FILTRO.

Y es que hay gente que son unos catacracs como este este CeeJay.dk. El filtro Lumasharpen es una adaptación del su software de mejora de imagen para juegos: PARA TODOS LOS JUEGOS (darbee en los juegos de PC, sí) Se llama SweetFX SweetFX Shader Suite Download Version 1.5 Y aparte del Lumasharpen esto aplica "bloom" entre otros muchos shaders con un rendimiento excelente para los juegos.

Pues bien, si nos centramos en el que está portado para TXT podemos conseguir cosas como estas con nuestras movies:

Atentos, aquí el filtro está bastante fuerte para que se aprecie bien en las fotos. No hagáis caso de la colorimetria por que mi cámara no es capaz de hacerlo mejor. Lo siento.

Antes:


Después:


Antes:


Después:


Antes:


Despues:


Vale... Insisto que están muy fuertes para que se vea bien. "Todo y que a mi me gusta que sea fuerte".

Vamos a lo práctico;

Como lo pongo en mi reproductor? Fácil.

/*
_____________________

LumaSharpen 1.4.1
_____________________

by Christian Cann Schuldt Jensen ~ CeeJay.dk

It blurs the original pixel with the surrounding pixels and then subtracts this blur to sharpen the image.
It does this in luma to avoid color artifacts and allows limiting the maximum sharpning to avoid or lessen halo artifacts.

This is similar to using Unsharp Mask in Photoshop.

Compiles with 3.0
*/

/*-----------------------------------------------------------.
/ User settings /
'-----------------------------------------------------------*/

#define sharp_strength 0.65
#define sharp_clamp 0.035
#define pattern 8
#define offset_bias 1.0
#define show_sharpen 0

/*-----------------------------------------------------------.
/ Developer settings /
'-----------------------------------------------------------*/
#define CoefLuma float3(0.2126, 0.7152, 0.0722) // BT.709 & sRBG luma coefficient (Monitors and HD Television)
//#define CoefLuma float3(0.299, 0.587, 0.114) // BT.601 luma coefficient (SD Television)
//#define CoefLuma float3(1.0/3.0, 1.0/3.0, 1.0/3.0) // Equal weight coefficient

/*-----------------------------------------------------------.
/ Main code /
'-----------------------------------------------------------*/

float4 p0 : register(c0);
sampler s0 : register(s0);

#define px (1.0 / p0[0])
#define py (1.0 / p0[1])

float4 main(float2 tex : TEXCOORD0) : COLOR0
{
// -- Get the original pixel --
float3 ori = tex2D(s0, tex).rgb; // ori = original pixel
float4 inputcolor = tex2D(s0, tex);

// -- Combining the strength and luma multipliers --
float3 sharp_strength_luma = (CoefLuma * sharp_strength); //I'll be combining even more multipliers with it later on

/*-----------------------------------------------------------.
/ Sampling patterns /
'-----------------------------------------------------------*/
// [ NW, , NE ] Each texture lookup (except ori)
// [ ,ori, ] samples 4 pixels
// [ SW, , SE ]

// -- Pattern 1 -- A (fast) 7 tap gaussian using only 2+1 texture fetches.
#if pattern == 1

// -- Gaussian filter --
// [ 1/9, 2/9, ] [ 1 , 2 , ]
// [ 2/9, 8/9, 2/9] = [ 2 , 8 , 2 ]
// [ , 2/9, 1/9] [ , 2 , 1 ]

float3 blur_ori = tex2D(s0, tex + (float2(px, py) / 3.0) * offset_bias).rgb; // North West
blur_ori += tex2D(s0, tex + (float2(-px, -py) / 3.0) * offset_bias).rgb; // South East

//blur_ori += tex2D(s0, tex + float2(px,py) / 3.0 * offset_bias); // North East
//blur_ori += tex2D(s0, tex + float2(-px,-py) / 3.0 * offset_bias); // South West

blur_ori /= 2; //Divide by the number of texture fetches

sharp_strength_luma *= 1.5; // Adjust strength to aproximate the strength of pattern 2

#endif

// -- Pattern 2 -- A 9 tap gaussian using 4+1 texture fetches.
#if pattern == 2

// -- Gaussian filter --
// [ .25, .50, .25] [ 1 , 2 , 1 ]
// [ .50, 1, .50] = [ 2 , 4 , 2 ]
// [ .25, .50, .25] [ 1 , 2 , 1 ]


float3 blur_ori = tex2D(s0, tex + float2(px, -py) * 0.5 * offset_bias).rgb; // South East
blur_ori += tex2D(s0, tex + float2(-px, -py) * 0.5 * offset_bias).rgb; // South West
blur_ori += tex2D(s0, tex + float2(px, py) * 0.5 * offset_bias).rgb; // North East
blur_ori += tex2D(s0, tex + float2(-px, py) * 0.5 * offset_bias).rgb; // North West

blur_ori *= 0.25; // ( /= 4) Divide by the number of texture fetches

#endif

// -- Pattern 3 -- An experimental 17 tap gaussian using 4+1 texture fetches.
#if pattern == 3

// -- Gaussian filter --
// [ , 4 , 6 , , ]
// [ ,16 ,24 ,16 , 4 ]
// [ 6 ,24 , ,24 , 6 ]
// [ 4 ,16 ,24 ,16 , ]
// [ , , 6 , 4 , ]

float3 blur_ori = tex2D(s0, tex + float2(0.4*px, -1.2*py)* offset_bias).rgb; // South South East
blur_ori += tex2D(s0, tex + float2(-1.2*px, -0.4*py) * offset_bias).rgb; // West South West
blur_ori += tex2D(s0, tex + float2(1.2*px, 0.4*py) * offset_bias).rgb; // East North East
blur_ori += tex2D(s0, tex + float2(-0.4*px, 1.2*py) * offset_bias).rgb; // North North West

blur_ori *= 0.25; // ( /= 4) Divide by the number of texture fetches

sharp_strength_luma *= 0.51;
#endif

// -- Pattern 4 -- A 9 tap high pass (pyramid filter) using 4+1 texture fetches.
#if pattern == 4

// -- Gaussian filter --
// [ .50, .50, .50] [ 1 , 1 , 1 ]
// [ .50, , .50] = [ 1 , , 1 ]
// [ .50, .50, .50] [ 1 , 1 , 1 ]

float3 blur_ori = tex2D(s0, tex + float2(0.5 * px, -py * offset_bias)).rgb; // South South East
blur_ori += tex2D(s0, tex + float2(offset_bias * -px, 0.5 * -py)).rgb; // West South West
blur_ori += tex2D(s0, tex + float2(offset_bias * px, 0.5 * py)).rgb; // East North East
blur_ori += tex2D(s0, tex + float2(0.5 * -px, py * offset_bias)).rgb; // North North West

//blur_ori += (2 * ori); // Probably not needed. Only serves to lessen the effect.

blur_ori /= 4.0; //Divide by the number of texture fetches

sharp_strength_luma *= 0.666; // Adjust strength to aproximate the strength of pattern 2
#endif

// -- Pattern 8 -- A (slower) 9 tap gaussian using 9 texture fetches.
#if pattern == 8

// -- Gaussian filter --
// [ 1 , 2 , 1 ]
// [ 2 , 4 , 2 ]
// [ 1 , 2 , 1 ]

half3 blur_ori = tex2D(s0, tex + float2(-px, py) * offset_bias).rgb; // North West
blur_ori += tex2D(s0, tex + float2(px, -py) * offset_bias).rgb; // South East
blur_ori += tex2D(s0, tex + float2(-px, -py) * offset_bias).rgb; // South West
blur_ori += tex2D(s0, tex + float2(px, py) * offset_bias).rgb; // North East

half3 blur_ori2 = tex2D(s0, tex + float2(0, py) * offset_bias).rgb; // North
blur_ori2 += tex2D(s0, tex + float2(0, -py) * offset_bias).rgb; // South
blur_ori2 += tex2D(s0, tex + float2(-px, 0) * offset_bias).rgb; // West
blur_ori2 += tex2D(s0, tex + float2(px, 0) * offset_bias).rgb; // East
blur_ori2 *= 2.0;

blur_ori += blur_ori2;
blur_ori += (ori * 4); // Probably not needed. Only serves to lessen the effect.

// dot()s with gaussian strengths here?

blur_ori /= 16.0; //Divide by the number of texture fetches

//sharp_strength_luma *= 0.75; // Adjust strength to aproximate the strength of pattern 2
#endif

// -- Pattern 9 -- A (slower) 9 tap high pass using 9 texture fetches.
#if pattern == 9

// -- Gaussian filter --
// [ 1 , 1 , 1 ]
// [ 1 , 1 , 1 ]
// [ 1 , 1 , 1 ]

float3 blur_ori = tex2D(s0, tex + float2(-px, py) * offset_bias).rgb; // North West
blur_ori += tex2D(s0, tex + float2(px, -py) * offset_bias).rgb; // South East
blur_ori += tex2D(s0, tex + float2(-px, -py) * offset_bias).rgb; // South West
blur_ori += tex2D(s0, tex + float2(px, py) * offset_bias).rgb; // North East

blur_ori += ori.rgb; // Probably not needed. Only serves to lessen the effect.

blur_ori += tex2D(s0, tex + float2(0, py) * offset_bias).rgb; // North
blur_ori += tex2D(s0, tex + float2(0, -py) * offset_bias).rgb; // South
blur_ori += tex2D(s0, tex + float2(-px, 0) * offset_bias).rgb; // West
blur_ori += tex2D(s0, tex + float2(px, 0) * offset_bias).rgb; // East

blur_ori /= 9; //Divide by the number of texture fetches

//sharp_strength_luma *= (8.0/9.0); // Adjust strength to aproximate the strength of pattern 2
#endif


/*-----------------------------------------------------------.
/ Sharpen /
'-----------------------------------------------------------*/

// -- Calculate the sharpening --
float3 sharp = ori - blur_ori; //Subtracting the blurred image from the original image

#if 0 //New experimental limiter .. not yet finished
float sharp_luma = dot(sharp, sharp_strength_luma); //Calculate the luma
sharp_luma = (abs(sharp_luma)*8.0) * exp(1.0 - (abs(sharp_luma)*8.0)) * sign(sharp_luma) / 16.0; //I should probably move the strength modifier here

#elif 0 //SweetFX 1.4 code
// -- Adjust strength of the sharpening --
float sharp_luma = dot(sharp, sharp_strength_luma); //Calculate the luma and adjust the strength

// -- Clamping the maximum amount of sharpening to prevent halo artifacts --
sharp_luma = clamp(sharp_luma, -sharp_clamp, sharp_clamp); //TODO Try a curve function instead of a clamp

#else //SweetFX 1.5.1 code
// -- Adjust strength of the sharpening and clamp it--
float4 sharp_strength_luma_clamp = float4(sharp_strength_luma * (0.5 / sharp_clamp), 0.5); //Roll part of the clamp into the dot

//sharp_luma = saturate((0.5 / sharp_clamp) * sharp_luma + 0.5); //scale up and clamp
float sharp_luma = saturate(dot(float4(sharp, 1.0), sharp_strength_luma_clamp)); //Calculate the luma, adjust the strength, scale up and clamp
sharp_luma = (sharp_clamp * 2.0) * sharp_luma - sharp_clamp; //scale down
#endif

// -- Combining the values to get the final sharpened pixel --
//float4 done = ori + sharp_luma; // Add the sharpening to the original.
inputcolor.rgb = inputcolor.rgb + sharp_luma; // Add the sharpening to the input color.

/*-----------------------------------------------------------.
/ Returning the output /
'-----------------------------------------------------------*/
#if show_sharpen == 1
//inputcolor.rgb = abs(sharp * 4.0);
inputcolor.rgb = saturate(0.5 + (sharp_luma * 4)).rrr;
#endif

return saturate(inputcolor);
}

Este es el código. Se trata de copiarlo y pegarlo en un TXT que guardaremos en la carpeta "unidad:\archivos de programa\Daumn\potplayer\Pxshder\" o la ruta de vuestro reproductor.

Para activarlo es como todos los shaders. No voy a entrar en ese detalle ahora.

Lo que sí que es importante es como modificar los valores para dejarlo al gusto. Yo por ejemplo he guardado varias copias del mismo pero con valores diferentes así según la película lo pongo más fuerte o más flojo.

Lo parámetros a modificar son estos:

// -- Sharpening --
#define sharp_strength 0.65 //[0.10 to 3.00] Strength of the sharpening
#define sharp_clamp 0.035 //[0.000 to 1.000] Limits maximum amount of sharpening a pixel recieves - Default is 0.035

// -- Advanced sharpening settings --
#define pattern 2 //[1|2|3|4] Choose a sample pattern. 1 = Fast, 2 = Normal, 3 = Wider, 4 = Pyramid shaped.
#define offset_bias 1.0 //[0.0 to 6.0] Offset bias adjusts the radius of the sampling pattern.
//I designed the pattern for offset_bias 1.0, but feel free to experiment.

Muy fácil. Yo os recomiendo poner un 2.0 en "#define sharp_strength" y un 6 en "#define offset_bias" y a partir de aquí empezar a bajar valores. (lo que pongo es muy fuerte, pero así veis lo que hace)

#define pattern 2 //[1|2|3|4] Choose a sample pattern. 1 = Fast, 2 = Normal, 3 = Wider, 4 = Pyramid shaped.
Esto cambia la forma de hacer lo que hace. Probad el 8 aunque aquí no lo ponga. Que es muy bueno.

Cuando cambiéis un valor no tenéis que cerrar el pot etc etc. Solo guardáis el documentos, desabilitais el filtro, lo habilitáis y ya se verán los cambios.

Otro filtro altamente recomendable:

/* --- Vibrance settings --- */

#define Vibrance 0.40 //Intelligently saturates (or desaturates if you use negative values) the pixels depending on their original saturation.


/* --- Defining Constants --- */

sampler s0 : register(s0);


/* --- Vibrance --- */
/*
by Christian Cann Schuldt Jensen ~ CeeJay.dk

Vibrance intelligently boosts the saturation of pixels
so pixels that had little color get a larger boost than pixels that had a lot.

This avoids oversaturation of pixels that were already very saturated.
*/

float4 VibrancePass( float4 colorInput )
{
float4 color = colorInput; //original input color
float3 lumCoeff = float3(0.2126, 0.7152, 0.0722); //Values to calculate luma with

float luma = dot(lumCoeff, color.rgb); //calculate luma (grey)

float max_color = max(max(colorInput.r,colorInput.g),colorInput.b); //Find the strongest color
float min_color = min(min(colorInput.r,colorInput.g),colorInput.b); //Find the weakest color

float color_saturation = max_color - min_color; //The difference between the two is the saturation

//color = lerp(luma, color, (1.0 + (Vibrance * (1.0 - color_saturation)))); //extrapolate between luma and original by 1 + (1-saturation)

color = lerp(luma, color, (1.0 + (Vibrance * (1.0 - (sign(Vibrance) * color_saturation))))); //extrapolate between luma and original by 1 + (1-saturation)

return color; //return the result
//return color_saturation.xxxx; //Visualize the saturation
}

/* --- Main --- */

float4 main(float2 tex : TEXCOORD0) : COLOR {
float4 c0 = tex2D(s0, tex);

c0 = VibrancePass(c0);

return c0;
}

Para cambiar el efecto hay que editar este parámetro:

#define Vibrance 0.40

Ponerlo en 2.0 y al ver que pasa lo bajáis. Es como pasar de ver una peli en blanco y negro a una en color

Es la polla literalmente, por que aumenta la saturación de las partes poco coloreadas. Así que no va a subir según que colores pero si subirá los que estén apagados. Alguien lo ha definido como una saturación inteligente y es muy buena definición.

Anexo de calibración: https://www.forodvd.com/tema/139676-...n/#post1407791