código de implementación basado en el algoritmo de filtro de la cámara varios y el GLSL OpenGL ES

        Sobre la base de los proyectos de código abierto nekocode / CameraFilter (Proyecto Dirección: https://github.com/nekocode/CameraFilter , el lector interesado puede descargar su propia para el código del proyecto que se ejecuta en el sistema Android), para explicar algunos de los filtros y el proyecto se ha implementado combino alguna función de filtro implementado algoritmos existentes en el proyecto. código del artículo en sí es relativamente sencilla, se basa en la implementación de OpenGL ES, podemos utilizar el código para este proyecto para aplicar rápidamente los algoritmos de diseño propio, no limitarse a los filtros, aquí que generalmente llamamos filtros.

       Filtrar, el algoritmo de núcleo de la presente proyecto se implementan fundamentalmente en shader fragmento de aplicación (shader fragmento). Aquí está la explicación principal correspondiente código shader fragmento. La figura Descripción breve de los parámetros de entrada y salida de acuerdo con shader fragmento.

Como parámetros de entrada y de salida se indican como se hace referencia en el presente documento, los parámetros de entrada para el shader fragmento y TexCoord iChannel0, respectivamente coordenadas de azulejos y datos de textura; parámetro de salida gl_FragColor, el valor de las coordenadas de color después del cálculo TexCoord. El borrado general aquí, particularmente importante para la comprensión de este artículo.

  • triple

void main() {
  if (texCoord.y <=  0.333){
       gl_FragColor = texture2D(iChannel0, vec2(texCoord.x,texCoord.y + 0.333));
    }else if (texCoord.y > 0.333 && texCoord.y<= 0.666){
       gl_FragColor = texture2D(iChannel0, texCoord);
    }else{
       gl_FragColor = texture2D(iChannel0, vec2(texCoord.x,texCoord.y - 0.333));
    }
 }
  • alivio

const highp vec3 transMatrix = vec3(0.2125, 0.7154, 0.0721);
const vec4 bgColor = vec4(0.5, 0.5, 0.5, 1.0);
void main() {
 	  vec2 currentUV = texCoord;
      vec2 preUV = vec2(currentUV.x-5.0/iResolution.x, currentUV.y-5.0/iResolution.y);
      vec4 currentMask = texture2D(iChannel0, currentUV);
      vec4 preMask = texture2D(iChannel0, preUV);
      vec4 delColor = currentMask - preMask;
      float luminance = dot(delColor.rgb, transMatrix);
      gl_FragColor = vec4(vec3(luminance), 0.0) + bgColor;
 }
  • Bañera de hidromasaje (Tai diagrama Chi)

const float PI = 3.14159265;
const float rotateRadian = PI/3.0;
const float radiusRatio = 0.8;
const float center = 0.5;
void main() {
    float radius = min(iResolution.x,iResolution.y)*radiusRatio/2.0;
    vec2 texCoord = texCoord;
    vec2 currentUV = texCoord;
    currentUV.x *= iResolution.x;
    currentUV.y *= iResolution.y;
    vec2 centerUV = iResolution.xy * center;
    vec2 deltaUV = currentUV - centerUV;
    float deltaR = length(deltaUV);
    float beta = atan(deltaUV.y, deltaUV.x) + rotateRadian * 2.0 * (-(deltaR/radius)*(deltaR/radius) + 1.0);
    vec2 dstUV = currentUV;
    if(deltaR <= radius){
        dstUV = centerUV + deltaR*vec2(cos(beta), sin(beta));
    }
    dstUV.x /=iResolution.x;
    dstUV.y /=iResolution.y;
    gl_FragColor = texture2D(iChannel0, dstUV);
 }
  • fundición

void main() {
 	 vec4 mask = texture2D(iChannel0, texCoord);
    vec4 tempColor = vec4(mask.r*0.5/(mask.g + mask.b + 0.01),
     mask.g*0.5/(mask.r + mask.b + 0.01),
     mask.b*0.5/(mask.r + mask.g + 0.01),
       1.0);
    gl_FragColor = tempColor;
 }
  • detección de bordes

void main() {
    vec4 color =  texture2D(iChannel0, texCoord);
    float gray = length(color.rgb);
    gl_FragColor = vec4(vec3(step(0.06, length(vec2(dFdx(gray), dFdy(gray))))), 1.0);
}
  • ola

void main() {
	float stongth = 0.3;
	vec2 uv = texCoord.xy;
	float waveu = sin((uv.y + iGlobalTime) * 20.0) * 0.5 * 0.05 * stongth;
	gl_FragColor = texture2D(iChannel0, uv + vec2(waveu, 0));
}

Con el desarrollo continuo de la tecnología, varios sensores están integrados en ordenadores, teléfonos móviles, robots y otros equipos, una combinación de la información física y algoritmos de reconocimiento de imágenes de percepción de estos sensores, podemos lograr efectos más potentes y en tiempo real.

Por ejemplo, en los últimos años, más de fuego pequeñas aplicaciones de vídeo vibrato o diestro, hay cientos de efectos especiales. El siguiente diagrama es varios efectos de vibrato, requiere una combinación de reconocimiento de la cara o de la medición de la profundidad de campo, el principio de aplicación de la sustitución de los píxeles restantes debería que he dicho hoy es similar. Estos efectos, si se aplica a una cámara estática, debería ser bastante fácil; sus mentiras dificultad en esta escena de vídeo dinámico, aún así ser capaz de lograr un buen tiempo real, sin efectos evidentes de retardo u otras imperfecciones y un menor consumo de energía, rendimiento optimizado es muy bueno.

En pocas palabras, entender y comprender el principio básico y el método de tratamiento de la imagen sigue siendo muy importante, sobre la base de estos principios y métodos pueden crear un efecto caleidoscópico.

nota:

(1) En este ejemplo y el color valores de coordenadas se normalizan (normalizada) en el intervalo tanto [0,1].

(2) desde el punto de vista de procesamiento de señales, procesamiento de imágenes se divide en el procesamiento de procesamiento de dominio y dominio de la frecuencia espacial. En este artículo se cubrió el ejército algoritmo en el dominio espacial.

 

material de referencia

https://www.jianshu.com/p/a771639ffbbb

https://github.com/nekocode/CameraFilter

Publicado cuatro artículos originales · ganado elogios 9 · vistas 5956

Supongo que te gusta

Origin blog.csdn.net/wudexiaoade2008/article/details/105105364
Recomendado
Clasificación