Imagen Digital

Procesamiento digital de imágenes

El procesamiento digital de imágenes es el conjunto de técnicas que se aplican a las imágenes digitales con el objetivo de mejorar la calidad o facilitar la búsqueda de información.

Las operaciones que se pueden realizar con imágenes se dividen en:
Operaciones de punto
Operaciones de entorno
Operaciones con dos o más imágenes

Fundamentos de imágenes digitales
Una imagen digital en escala de grises es un matriz de MxN elementos numéricos cuyos valores posibles van del 0 (negro) al 255 (blanco), siendo este número la intensidad luminosa en el determinado punto o pixel (picture element), por convención el origen de la imagen se encuentra en el extremo izquierdo superior.

Una imagen digital a colores esta formada por 3 matrices de MxN elementos numéricos cuyos valores posibles van del 0 (negro) al 255 (blanco), siendo este número la intensidad luminosa en cada una de las bandas espectrales del RGB (Rojo, Verde, Azul), de cada punto o pixel (picture element), a diferencia de las imágenes en escala de grises, las imágenes a color requieren de la combinación de las 3 bandas de color, para representar el color de un pixel.
Por ejemplo, un determinado punto blanco de una imagen en escala de grises se describiría: P(x, y) =255, sin embargo en una imagen a colores para describir el color del mismo punto se realizaría así: P(x, y) = (255, 255,255), esto debido a que el (0, 0,0) corresponde al negro absoluto y el (255, 255,255) al blanco absoluto).

Detección de movimiento

Los filtros se utilizan para la modificación de imágenes ya sea para detectar los bordes de una escena o para modificar el aspecto, otra función de los filtros es para la eliminación de ruido de la imagen.Al hablar de un filtro nos estamos refiriendo a realizar una Convolución de una matriz con respecto a un pixel y la vecindad de este, esto quiere decir, si la imagen es de 200x300 pixeles y el filtro con el cual se va a realizar la convolución es una matriz de 3x3 entonces se irá desplazando el filtro pixel a pixel iniciando en la posición (1,1) hasta llegar a la (199,299). La magnitud del gradiente es entonces calculada con la siguiente fórmula:

Una magnitud aproximada puede ser calculada de la siguiente forma:

Filtros para la detección de bordes

Imagen Original

Detección de bordes con Prewitt

Detección de bordes con Sobel

Un filtro para la detección de bordes que es un clásico el de Sobel el cual utiliza dos mascaras o filtros los cuales uno detecta los bordes verticales y el otro los horizontales, para obtener los bordes completos se realiza la suma de las imágenes que nos resultaron con los bordes verticales y horizontales. Otro filtro para la detección de bordes es Prewitt, el cual consta de 8 matrices, que se aplican pixel a pixel en la imagen y luego se suman las imágenes para obtener los bordes bien marcados. El filtro de Prewitt, marca muy bien los bordes, ya que sus matrices atacan estos de seis lados diferentes, en general cada matriz toma el nombre de un punto cardinal: Norte, Sur, Este, Oeste, Noroeste, Noreste, Suroeste, Sureste.

Imagen Estática

Se divide en dos tipos:

• mapa de bits
• vectoriales

Tipos de imagenes de mapa de bits

• 1bit x un pixel En este tipo de imágenes cada celdilla (píxel) sólo puede tener uno de dos valores: uno o cero. Como basta 1 bit para definir esa alternativa, se les llama “imágenes de 1 bit” (también se les llama “imágenes de mapa de bits, de alto contraste, o de línea”).

• Escala de Grises Cada píxel puede tener 256 valores diferentes (las 256 posibilidades combinatorias de un byte u octeto). Este es el modo de las imágenes digitales de blanco y negro “normales”. Aunque pueda parecer increíble, en ellas se distinguen hasta 256 tonos diferentes de gris (y no suelen aparecer todos a la vez, por cierto).

• RGB o LAB Si tomamos un píxel y le asignamos tres bytes, dispondremos de 24 bits en tres grupos de ocho. Podemos “colorearlo” siguiendo el sistema de color de los monitores de televisión, que se basan en tres “canales” de luz de color (Rojo, Azul y Verde). De este modo podemos distinguir hasta 16.777.216 millones de tonos de color ( 256 Rojo × 256 Azul × 256 Verde).

Imagenes Vectoriales
Las imágenes vectoriales de dos dimensiones suelen tener varias partes. Sólo el contorno y el relleno serán visibles al imprimir. Lo demás son instrumentos de trabajo. La base de estas operaciones son las llamadas “Curvas Bezier”

Imagen Digital

Imagen: puedo comenzar por decir que imagen es una representacion de algo real o imaginario basados en luz sobre la vision humana.

Imagen Digital: Es una representacion bidimencional de una imagen utilizando 1 y 0 depende de la resolucion de la misma para saber si es un gráfico rasterizado o un gráfico vertical.

Para obtener una imagen digital mediante conversion análogica-digital se utilizan medios tecnologicos

como camaras, scanners, etc. y para la creaccion de una imagen unicamente es necesario el software y los

dispositivos de interfaz unama como son el raton, teclado, lapiz optico etc.

Resolucion de una imagen Digital: Es el número de celdas o unidades minimas de impresión que una maquina es capaz de realizar. A mayor resolucion mejor nitidez del dibujo. Generalmente la resolucion se mide en ppp(puntos por pulgada)

Imagenes de mapa de bits: el mapa de bits no es mas que el # de 1 o 0 que pueden estar dentro de una celdilla (pixel). Entre las Imagenes de Mapa de Bits las mas comunes estan:

1 bit por pixel (negativos)

8 bits por pixel (Scala de Grises)

24 bits por pixel (imagenes RGB)

32 bits por pixel (CMYK) tipo de imagen profecional

ŁЄØИΛRĐØ ™

Imagen Digital

Conocimientos Previos:

• Pixel --> El píxel es la unidad mínima de información de una imagen digital, puede
  

tener hasta 16,7 millones de colores.

• Tamaño --> Describe sus dimensiones físicas y se mide en píxeles.

• Resolución --> Indica el número de píxeles que caben en cada unidad de longitud (ppp).

Formatos de archivo gráfico

Un formato gráfico define la manera en que se guarda una imagen y toda la información relacionada con la misma.

• BMP: Es el formato nativo de Windows. Cualquier aplicación será capaz de reconocerlo. Admite hasta 16,7 millones de colores pero el tamaño de los archivos que genera es enorme para casi cualquier uso.

• GIF: Formato muy utilizado en Internet para la creación de textos y gráficos gracias a su pequeño tamaño. Su inconveniente es que admite tan sólo 256 colores.
  

• TIFF: Es el formato elegido para los trabajos de gran calidad de imprenta. Admite compresión sin perdida de calidad (LZW) y es leído tanto por sistemas PC como Mac.

• JPEG: Es el formato de compresión de imágenes más eficiente de la actualidad. Al guardar una imagen en este formato debemos de especificar la cantidad de compresión a emplear.

Tipos de imagen

A grandes rasgos podríamos dividir las imágenes digitales en dos grandes grupos:

• Raster o Vectoriales La información de cada uno de los puntos se recoge en forma de ecuación mátemática que lo relaciona con el resto de los puntos que forman la imagen.

• Mapa de Bits o Bbitmap Se construyen describiendo cada uno de los puntos que componen la imagen y llevan, por tanto, información acerca de la posición absoluta y el color de cada uno de ellos.

GRAFICA DE TAREA 2

Acontinuacion se puede observar lo que es la grafica del año 93 al 2008 de la tarea 2

TAREA 2

zt=[10056 18573 20195 21268 23635 23255 16675 15934 21250 24899 28636 32642 37187 41763 45789 48508 ]';
plot(zt)
n=length(zt)
zt1=[0;zt(1:n-1)]
zt2=[0;0;zt(1:n-2)]
x=[zt1 ,zt2]
b=inv(x'*x)*(x'*zt)

s=poly(0,'s')
s=s^2-b(1)*s-b(2)
raiz = roots (s)

alfa=real (raiz(1))
bet=imag (raiz(1))
r= sqrt (alfa^2+bet^2)
teta=acos(alfa/r)

t=[1:n]';
z1=(r.^t).* cos(teta*t)
z2=(r.^t).* sin(teta*t)

x=[z1 ,z2]
a=inv (x'*x)*(x'*zt)
z=a(1)*z1+a(2)*z2
plot(t,[zt z])
error1=zt-z


t=[1:0.1:n]';
z1=(r.^t).* cos(teta*t)
z2=(r.^t).* sin(teta*t)
z=a(1)*z1+a(2)*z2
plot(t,z)

Realizar la proyección de 1998 al 2000, con los datos del 93 al 97

PIB del BCE

La gráfica

Realizar proyección del 2008 con los datos del 2005 al 2007.

Datos:

pib=[ 2.814 3.115 3.366]'

n=length(pib)

pib1=[0;pib(1:n-1)]

pib2=[0;0;pib(1:n-2)]

x=[pib1 pib2]

b=inv(x'*x)*(x'*pib)

s=poly(0,'s')

s=s^2-b(1)*s-b(2)

raiz=roots(s)

t=[1:n]'

p1=exp(raiz(1)*t)

p2=exp(raiz(2)*t)

x=[p1 p2]

A=inv(x'*x)*(x'*pib)

z=A(1)*p1+A(2)*p2

plot(t,pib)t=[1:0.1:+1]';

z1=exp(raiz(1)*t)

z2=exp(raiz(1)*t)

z=A(1)*z1+A(2)*z2

plot(t,z)

La clase Matriz

A continuacion presento la clase matriz

PIB -> 2005 al 2007 con proyección al 2008

pib=[2.814 3.115 3.366]'
n=length(pib)
pib1=[0;pib(1:n-1)]
pib2=[0;0;pib(1:n-2)]
x=[pib1 pib2]
b=inv(x'*x)*(x'*pib)
s=poly(0,'s')
s=s^2-b(1)*s-b(2)
raiz=roots(s)
t=[1:n]'
p1=exp(raiz(1)*t)
p2=exp(raiz(2)*t)
x=[p1 p2]
A=inv(x'*x)*(x'*pib)
z=A(1)*p1+A(2)*p2
plot(t,pib)
t=[1:0.1:n+1]'
z1=exp(raiz(1)*t)
z2=exp(raiz(2)*t)
z=A(1)*z1+A(2)*z2
plot(t,z)

PIB -> 93 al 97 con proyección al 98,99, 2000

pib=[1.460 1.660 1.772 1.835 2.008 ]'
n=length(pib)
p1=[0;pib(1:n-1)]
p2=[0;0;pib(1:n-2)]
x=[p1 p2]
b=inv(x'*x)*(x'*pib)
s=poly(0,'s')
s=s^2-b(1)*s-b(2)
raiz=roots(s)
t=[1:n]'
x1=exp(raiz(1)*t)
x2=exp(raiz(2)*t)
x=[x1 x2]
A=inv(x'*x)*(x'*pib)
z=A(1)*x1+A(2)*x2
plot(t,pib)
t=[1:n+3]';
z1=exp(raiz(1)*t)
z2=exp(raiz(2)*t)
z=A(1)*z1+A(2)*z2
plot(t,z)

Ejercicios PIB

----------------------------------------------1-------------------------------------------------
pib=[1.460 1.660 1.772 1.835 2.008 ]'
n=length(pib)
p1=[0;pib(1:n-1)]
p2=[0;0;p1(1:n-1)]
x=[p1 p2]
b=inv(x'*x)*(x'*pib)
s=poly(0,'s')
s=s^2-b(1)*s-b(2)
raiz=roots(s)
t=[1:n]'
x1=exp(raiz(1)*t)
x2=exp(raiz(2)*t)
x=[x1 x2]
A=inv(x'*x)*(x'*pib)
z=A(1)*x1+A(2)*x2
plot(t,pib)t=[1:n+2]';
z1=exp(raiz(1)*t)
z2=exp(raiz(2)*t)
z=A(1)*z1+A(2)*z2
plot(t,z)
----------------------------------------------2-------------------------------------------------
pib=[1.460 1.660 1.772 1.835 2.008 1.946 1.376 1.296 1.703 1.967 2.230 2.506 2.814 3.115 3.366]'
n=length(pib)
p1=[0;pib(1:n-1)]
p2=[0;0;p1(1:n-1)]
x=[p1 p2]
b=inv(x'*x)*(x'*pib)
s=poly(0,'s')
s=s^2-b(1)*s-b(2)
raiz=roots(s)
t=[1:n]'
x1=exp(raiz(1)*t)
x2=exp(raiz(2)*t)
x=[p1 p2]
A=inv(x'*x)*(x'*pib)
z=A(1)*x1+A(2)*x2
plot(t,pib)
z=[1:n+1]';
z1=exp(raiz(1)*t)
z2=exp(raiz(2)*t)
z=A(1)*z1+A(2)*z2
plot(t,pib)

ŁЄØИΛRĐØ ™

PIB

Realizar la proyección para el 2008
Para ello use datos desde el 2005 al 2007
Realizar la proyección para el 98, 99, 2000
Para ello he usado datos desde el 93 al 97

Matriz

ŁЄØИΛRĐØ ™

MATRIZ

import java.io.*;
public class MenuMatriz
{
public static void main(String args[])
{
Operaciones obj= new Operaciones();
Leer Lee = new Leer();
int op;
do
{
System.out.println("n MENU ");
System.out.println(" [1] SUMA");
System.out.println(" [2] RESTA");
System.out.println(" [3] MULTIPLICACCION");
System.out.println(" [4] DIVICION");
System.out.println(" [5] SALIR");
System.out.print("n ESCOJER OPCION : ");
op=Lee.datoInt();
switch (op)
{
case 1: obj.Suma(); break;
case 2: obj.Resta(); break;
case 3: obj.Multiplicacion(); break;
case 4: obj.Division(); break;
case 5: System.out.println("nFin del programa."); break;
default: System.out.println("n Error ");
}
}while(op!=5);
}
}
class Leer
{
public static String dato()
{
String sdato="";
try
{
InputStreamReader isr = new InputStreamReader (System.in);
BufferedReader flujo =new BufferedReader (isr);
sdato=flujo.readLine();
}
catch (IOException e)
{
System.err.println("Error"+ e.getMessage());
}
return sdato;
}
public static int datoInt()
{
try
{
return Integer.parseInt (dato());
}
catch(NumberFormatException e)
{
return Integer.MIN_VALUE;
}
}
public static float datoFloat()
{
try
{
Float f = new Float(dato());
return f.floatValue();
}
catch(NumberFormatException e)
{
return Float.NaN; // No es un Número; valor float.
}
}
}
class Operaciones
{
void Muestra(float M[][],int F,int C)
{
for(int y=0; y {
System.out.print("n");
for(int x=0; x System.out.print(M[x][y]+" ");
}
}
void Muestra(int M[][],int F,int C)
{
for(int y=0; y {
System.out.print("n");
for(int x=0; x System.out.print(M[x][y]+" ");
}
}

boolean Compara(int AX,int AY,int BX,int BY)
{
if ((AX==BX && AY==BY))
return true;
return false;
}

boolean Compara(int AX,int BY)
{
if ((AX==BY))
return true;
return false;
}

void Suma()
{
Leer Lee = new Leer();
Operaciones Obj= new Operaciones();
int FA=0;
int FB=0;
int CA=0;
int CB=0;
System.out.println("n ingrese el número de Filas y Columnas de la matrice.");
System.out.print("n Filas de A:"); FA=Lee.datoInt();
System.out.print("n Filas de B:"); FB=Lee.datoInt();
System.out.print("n Columnas de A:"); CA=Lee.datoInt();
System.out.print("n Columnas de B:"); CB=Lee.datoInt();
int A[][] = new int[CA][FA];
int B[][] = new int[CB][FB];
int S[][] = new int[CA][FB];
if (Obj.Compara(CA,FA,CB,FB))
{
System.out.println("n datos de A:");
for(int y=0; y for(int x=0; x {
System.out.print("A["+(x+1)+"]["+(y+1)+"] = "); A[x][y]= Lee.datoInt();
}
System.out.println("n datos de B:");
for(int y=0; y for(int x=0; x {
System.out.print("B["+(x+1)+"]["+(y+1)+"] = "); B[x][y]= Lee.datoInt();
}
System.out.println("nMatriz A:n");
Obj.Muestra(A,FA,CA);
System.out.println("nMatriz B:n");
Obj.Muestra(B,FB,CB);
for(int y=0; y for(int x=0; x S[x][y]=A[x][y]+B[x][y];
System.out.println("nLa suma es:n");
Obj.Muestra(S,FA,CB);
}
else
{

System.out.println("n Al sumarce las matrices tienen que tener las mismas dimenciones");
}
}
void Resta()
{
Leer Lee = new Leer();
Operaciones Obj= new Operaciones();
int FA=0;
int FB=0;
int CA=0;
int CB=0;
System.out.println("n ingrese el número de Filas y Columnas dela matrice.");
System.out.print("n Filas de A:"); FA=Lee.datoInt();
System.out.print("n Filas de B:"); FB=Lee.datoInt();
System.out.print("n Columnas de A:"); CA=Lee.datoInt();
System.out.print("n Columnas de B:"); CB=Lee.datoInt();
int A[][] = new int[CA][FA];
int B[][] = new int[CB][FB];
int S[][] = new int[CA][FB];
if (Obj.Compara(CA,FA,CB,FB))
{
System.out.println("n Datos de A:");
for(int y=0; y for(int x=0; x {
System.out.print("A["+(x+1)+"]["+(y+1)+"] = "); A[x][y]= Lee.datoInt();
}
System.out.println("n Datos de B:");
for(int y=0; y for(int x=0; x {
System.out.print("B["+(x+1)+"]["+(y+1)+"] = "); B[x][y]= Lee.datoInt();
}
System.out.println("n Matriz A:n");
Obj.Muestra(A,FA,CA);
System.out.println("n Matriz B:n");
Obj.Muestra(B,FB,CB);
for(int y=0; y for(int x=0; x S[x][y]=A[x][y]+(B[x][y]*-1);
System.out.println("nLa resta es:n");
Obj.Muestra(S,FA,CB);
}
else
{
System.out.println("n Al restarse las matrices tienen que tener las mismas dimenciones");
}
}

void Multiplicacion()
{
Leer Lee = new Leer();
Operaciones Obj= new Operaciones();
int FA=0;
int FB=0;
int CA=0;
int CB=0;
int suma=0;
int h=0;
System.out.println("n ingrese el número de Filas y Columnas de la matrices.");
System.out.print("n Filas de A:"); FA=Lee.datoInt();
System.out.print("n Filas de B:"); FB=Lee.datoInt();
System.out.print("n Columnas de A:"); CA=Lee.datoInt();
System.out.print("n Columnas de B:"); CB=Lee.datoInt();
int A[][] = new int[CA][FA];
int B[][] = new int[CB][FB];
int S[][] = new int[CA][FB];
if (Obj.Compara(CA,FB))
{
System.out.println("n Datos de A:");
for(int y=0; y for(int x=0; x {
System.out.print("A["+(x+1)+"]["+(y+1)+"] = "); A[x][y]= Lee.datoInt();
}
System.out.println("n Datos de B:");
for(int y=0; y for(int x=0; x {
System.out.print("B["+(x+1)+"]["+(y+1)+"] = "); B[x][y]= Lee.datoInt();
}

System.out.println("nMatriz A:n");
Obj.Muestra(A,FA,CA);
System.out.println("nMatriz B:n");
Obj.Muestra(B,FB,CB);
for(int y=0; y for(int x=0; x {
h=0;
suma=0;
while(h {
suma+=A[h][y]*B[x][h];
h++;
}
S[x][y]=suma;
}
System.out.println("n La multiplicacion es:n");
Obj.Muestra(S,FA,CB);
}
else
{
System.out.println("n Al multiplicarse el numero de columnas de la matriz A tiene que ser igual nal numero de filas de la matriz B");
}
}
void Division()
{
Leer Lee = new Leer();
Operaciones Obj= new Operaciones();
int FB=0;
int CB=0;
int FA=0;
int CA=0;
int suma=0;
float aux=0;
int h=0;
System.out.println("n Ingrese el número de Filas y Columnas de la matrice");
System.out.print("n Filas de A:"); FA=Lee.datoInt();
System.out.print("n Filas de B:"); FB=Lee.datoInt();
System.out.print("n Columnas de A:"); CA=Lee.datoInt();
System.out.print("n Columnas de B:"); CB=Lee.datoInt();
float A[][] = new float [CB][FB];
float B[][] = new float [CB][FB];
float S[][] = new float [CB][FB];
float I[][] = new float [CB][FB];
float C[][] = new float [CB][FB];
if(Obj.Compara(CA,FB))
{
System.out.println("n Datos de A:");
for(int y=0; y for(int x=0; x {
System.out.print("A["+(x+1)+"]["+(y+1)+"] = "); A[x][y]= Lee.datoFloat();
}
System.out.println("n Datos de B:");
for(int y=0; y for(int x=0; x {
System.out.print("B["+(x+1)+"]["+(y+1)+"] = "); B[x][y]= Lee.datoFloat();
}
System.out.println("n Matriz A:n");
Obj.Muestra(B,FB,CB);
System.out.println("n Matriz B:n");
Obj.Muestra(B,FB,CB);

for(int y=0; y for(int x=0; x {
h=0;
suma=0;
while(h {
suma+=A[h][y]*I[x][h];
h++;
}
S[x][y]=suma;
}
System.out.println("nLa division es:n");
Obj.Muestra(S,FB,CB);
}
else
{
System.out.println("n al dividirse el numero de columnas de la matriz A tiene que ser igual al numero de filas de la matriz B, y debe ser una matriz cuadrada.");
}
}
}

Clase Matriz