Edge Detection

Textos Universitarios / Serie Docencia
________________________________________________________________________
375
Captulo 8
Procesamiento digital de imgenes

8.1 Introduccin
El procesamiento digital de imgenes aparece tardamente en la historia de la
computacin, ya que antes de pensar en ello, haba que desarrollar el hardware y los
sistemas operativos grficos que permitieran hacerlo. Por otro lado, los algoritmos y las
tcnicas de optimizacin que han tenido que desarrollarse para el procesamiento digital
de imgenes son muy sofisticados y elaborados. En la actualidad existen muchas
aplicaciones de software que permiten el procesamiento digital de imgenes, mucho de
este utiliza tcnicas o algoritmos que son bien conocidos por la comunidad que trabaja en
ello, pero otros utilizan sus propias variantes o tcnicas nuevas que estn poco
documentadas.

En este captulo veremos diferentes tcnicas que existen para procesar imgenes, estas
tcnicas podemos agruparlas en tres grandes grupos:

Modificacin de Color
Modificacin de Imagen
Generacin de efectos.

Despus de explicar en que consisten, presentaremos el cdigo de la clase gImage en la
que se han definido varios mtodos para que el usuario pueda procesarlas mediante un
programa genrico que permite subir imgenes a un servidor Web.

8.1.1 Bitmaps (mapas de bits)
La manera bsica y original de representar una imagen digital con color en la memoria de
la computadora es un bitmap. Un bitmap esta formado por filas de pixeles, donde cada
uno en particular tiene un valor que determina su color. Este valor esta formado por tres
nmeros en el rango 0 a 255, asociados a los colores primarios Rojo, Verde y Azul.
Cualquier color visible al ojo humano puede representarse de esta manera. Por ejemplo el
color negro se codifica como R=0, V=0, A=0 y el color blanco (R,V,A) =(255,255,255).
Desde este punto de vista, una imagen es un arreglo bidimensional de pixeles cada uno
codificado en 3 bytes que puede tener 256x256x256=16.8 millones de diferentes colores.
Esta tcnica se conoce como codificacin RGB y est adaptada a la visin humana. Sin
embargo hay otras tcnicas de codificacin donde las cmaras o dispositivos de medicin
juegan un papel predominante.
El rango de 0 a 255 se acord por dos razones. La primera debido a que el ojo humano no
es lo suficientemente sensible como para diferenciar ms de 256 niveles de intensidad
para un color y por otro lado es la capacidad de almacenamiento para un byte desde el
punto de vista de la computacin.

Jenaro C. Paz
________________________________________________________________________
376
8.1.2 Representacin vectorial de los colores
Como hemos mencionado, en un mapa de bits, los colores se codifican en tres bytes
representando su descomposicin en los tres colores primarios. Matemticamente puede
interpretarse un color como un vector en el espacio tridimensional de Rojo, Verde y Azul.
Bajo esta interpretacin pueden aplicarse algunos conceptos de la geometra analtica en
el tratamiento de colores y en la generacin de filtros o transformaciones.

Figura 8.1 Espacio tridimensional de colores

Una imagen es una codificacin en un dominio espacial bidimensional esttico y esto nos
permite que podamos contar con nuevas imgenes a partir de las originales sin tener que
modificarlas haciendo uso de transformaciones o filtros aplicados a sus pixeles.

Si consideramos una imagen con resolucin de 512 x 384 pixeles, su almacenamiento sin
compresin ser en 590 Kbytes y otra de 2592 x 1728 pixeles estar almacenada en 13.4
Mbytes. Con tcnicas de compresin, esta ultima puede almacenarse en un archivo de 2.9
Mbytes. Para las transformaciones y filtros que aplicaremos estaremos tratando con las
imgenes, con esos espacios bidimensionales, que difieren mucho de los diferentes
formatos de archivos en que las podemos almacenar en un disco duro por ejemplo.

Para acceder a los datos de una imagen Bitmap a continuacin presentamos la clase
BitmapData que utilizaremos un poco ms adelante en diferentes aplicaciones en el
procesamiento digital de imgenes.

8.1.3 Clase BitmapData
34

Requisitos

Espacio de nombres: System.Drawing.Imaging

34
http://msdn2.microsoft.com/en-us/library/system.drawing.imaging.bitmapdata(VS.80).aspx
J unio 3 de 2006
________________________________________________________________________
377
Especifica los atributos de una imagen de mapa de bits. La clase BitmapData la utilizan
los mtodos LockBits y UnlockBits de la clase Bitmap. No puede heredarse.
8.1.3.1 Constructores pblicos
BitmapData (Constructor) Inicializa una nueva instancia de la clase
BitmapData.
8.1.3.2 Propiedades pblicas
Height Obtiene o establece el alto en pxeles del
objeto Bitmap. A veces se denomina
nmero de lneas de exploracin.
PixelFormat Obtiene o establece el formato de la
informacin de pxeles en el objeto Bitmap
que este objeto BitmapData devuelve.
Reserved Reservado. No utilizar.
Scan0 Obtiene o establece la direccin de los datos
del primer pxel en el mapa de bits.
Tambin corresponde a la primera lnea de
exploracin del mapa de bits.
Stride Obtiene o establece el ancho de paso
(tambin denominado ancho de exploracin)
del objeto Bitmap.
Width Obtiene o establece el ancho en pxeles del
objeto Bitmap. Tambin corresponde al
nmero de pxeles de una lnea de
exploracin.
8.1.3.3 Mtodos pblicos
Equals (se hereda de Object) Sobrecargado. Determina si dos instancias
de Object son iguales.
GetHashCode (se hereda de Object) Sirve como funcin hash para un tipo
concreto, apropiado para su utilizacin en
algoritmos de hash y estructuras de datos
como las tablas hash.
GetType (se hereda de Object) Obtiene el objeto Type de la instancia
actual.
ToString (se hereda de Object) Devuelve un objeto String que representa al
objeto Object actual.
8.1.3.4 Mtodos protegidos
Jenaro C. Paz
________________________________________________________________________
378
Finalize (se hereda de Object) Reemplazado. Permite que un objeto Object
intente liberar recursos y realizar otras
operaciones de limpieza antes de que el
objeto Object sea reclamado por el
recolector de elementos no utilizados.
En C#y C++, los finalizadores se expresan
mediante la sintaxis del destructor.
MemberwiseClone (se hereda de Object) Crea una copia superficial del objeto Object
actual.

8.2 Procesamiento de Imgenes

8.2.1 Modificacin de Color
En esta seccin cubriremos algunas de las tcnicas ms conocidas que estn relacionadas
con la modificacin que se hace a los pixeles de una imagen sin que estos cambien de
posicin.

8.2.1.1 Deteccin de orillas
De lo mencionado en prrafos anteriores, podemos cuantificar la diferencia entre dos
colores calculando la distancia geomtrica entre los vectores que los representan.
Consideremos dos colores C1 =(R1, G1, B1) y C2 =(R2, G2, B2), la distancia entre
ellos esta dada por la frmula:

El objetivo en la deteccin de orillas es determinar las orillas de las formas en una
imagen y ser capaz de dibujar un bitmap resultante donde las orillas estn en blanco sobre
un fondo negro. La idea es muy sencilla, nos desplazamos por la imagen pixel por pixel
comparando el color de cada uno con su vecino de la derecha y de abajo. Si alguna de
estas comparaciones resulta en una diferencia muy grande el pixel estudiado es parte de
una orilla y debe ponerse en blanco, de otra manera se pone en negro. Para llevar a cabo
la comparacin de colores entre pixeles lo haremos mediante apuntadores, ya que .Net no
cuenta con un mtodo que permita acceder a los datos de un pxel en forma directa.

Figura 8.2. Representacin de una imagen en memoria

Refirindonos a la figura anterior, BitmapData es la clase que mediante sus mtodos
Stride y Scan0 nos permitir acceder a la informacin de la imagen en cuestin.
________________________________________________________________________
379

Figura 8.3. Representacin de una imagen de dimensin Width x Height

A continuacin se presenta la Clase gImage que iremos agrandando con nuevos mtodos
segn vayamos avanzando en los diferentes temas asociados con el procesamiento digital
de imgenes. El primer mtodo que se ha incluido es EdgeDetect que se utiliza para la
deteccin de orillas. Para entender el funcionamiento del mismo se hace uso de las
figuras 8.2 y 8.3, donde se inicia haciendo un recorrido por todos los bytes de la imagen
rengln por rengln y columna por columna. Tenga en cuenta que cada vez que termina
un rengln hay que avanzar nOffset bytes para acceder al siguiente y as sucesivamente.

gImage.cs

usi ng Syst em;
usi ng Syst em. Dr awi ng;
usi ng Syst em. Dr awi ng. I magi ng;
usi ng Syst em. Dr awi ng. Dr awi ng2D;

namespace J CPGr aphi cs
{
/ / / <summar y>
/ / / Summar y descr i pt i on f or gI mage.
/ / / </ summar y>
publ i c cl ass gI mage
{
publ i c gI mage( )
{
/ /
/ / TODO: Add const r uct or l ogi c her e
/ /
}
publ i c st at i c Bi t map EdgeDet ect ( Bi t map cur I mage, byt e nThr eshol d)
Jenaro C. Paz
________________________________________________________________________
380
{
Bi t map bCl one = ( Bi t map) cur I mage. Cl one( ) ;
Bi t mapDat a bmDat a = cur I mage. LockBi t s( new Rect angl e( 0, 0,
cur I mage. Wi dt h, cur I mage. Hei ght ) , I mageLockMode. ReadWr i t e,
Pi xel For mat . For mat 24bppRgb) ;
Bi t mapDat a bmDat aC = bCl one. LockBi t s( new Rect angl e( 0, 0,

/ / st r i de = ancho de una l i nea de pi xel es
i nt st r i de = bmDat a. St r i de;

/ / Di r ecci on de l os dat os del pr i mer pi xel
Syst em. I nt Pt r Scan0 = bmDat a. Scan0;
Syst em. I nt Pt r Scan0C = bmDat aC. Scan0;
doubl e cRed, cGr een, cBl ue;

unsaf e
{
byt e * p = ( byt e *) Scan0;
byt e * p2 = ( byt e *) Scan0C;
i nt nWi dt h = cur I mage. Wi dt h * 3; / / 3 byt es por pi xel
i nt nOf f set = st r i de - nWi dt h;

/ / | - - - - - - - - - - - - - pi xel es- - - - - - - - - - - - - - - - | - - nOf f set - - |

i nt nPi xel 1 = 0, nPi xel 2 = 0;
f or ( i nt y=0; y<cur I mage. Hei ght - 1; y++)
{
f or ( i nt x=0; x < nWi dt h- 3; x++ )
{
cRed=Mat h. Pow( Mat h. Abs( p2[ 0] - ( p2+3) [ 0] ) , 2) ;
cGr een=Mat h. Pow( Mat h. Abs( p2[ 1] - ( p2+3) [ 1] ) , 2) ;
cBl ue=Mat h. Pow( Mat h. Abs( p2[ 2] - ( p2+3) [ 2] ) , 2) ;

nPi xel 1=( i nt ) Mat h. Sqr t ( cRed+cGr een+cBl ue) ;

cRed=Mat h. Pow( Mat h. Abs( p2[ 0] - ( p2+st r i de) [ 0] ) , 2) ;
cGr een=Mat h. Pow( Mat h. Abs( p2[ 1] - ( p2+st r i de) [ 1] ) , 2) ;
cBl ue=Mat h. Pow( Mat h. Abs( p2[ 2] - ( p2+st r i de) [ 2] ) , 2) ;

nPi xel 2=( i nt ) Mat h. Sqr t ( cRed+cGr een+cBl ue) ;
i f ( ( nPi xel 1>=nThr eshol d) | | ( nPi xel 2 >= nThr eshol d) )
nPi xel 1 = 255;
el se
nPi xel 1 = 0;
p[ 0] = p[ 1] =p[ 2] =( byt e) nPi xel 1;

p++;
p2++;
}
p +=nOf f set ;
p2 +=nOf f set ;
}
}
cur I mage. Unl ockBi t s( bmDat a) ;
bCl one. Unl ockBi t s( bmDat aC) ;
________________________________________________________________________
381

r et ur n cur I mage;
}
}
}

Para hacer uso de esta biblioteca implementamos una forma Web como la siguiente:

Figura 8.4. Forma Web para subir una imagen al servidor IIS

Que nos permitir hacer la bsqueda de una imagen en la computadora del usuario y
luego subirla al servidor Web.

UploadEdgeDetection.aspx

<%@Page l anguage=" c#" Codebehi nd=" Upl oadEdgeDet ect i on. aspx. cs"
Aut oEvent Wi r eup=" f al se" I nher i t s=" J CPGr aphi cs. Upl oadEdgeDet ect i on" %>
<! DOCTYPE HTML PUBLI C " - / / W3C/ / DTD HTML 4. 0 Tr ansi t i onal / / EN" >
<HTML>
<HEAD>
<t i t l e>WebFor m1</ t i t l e>
<met a cont ent =" Mi cr osof t Vi sual St udi o . NET 7. 1"
name=" GENERATOR" >
<met a cont ent =" C#" name=" CODE_LANGUAGE" >
<met a cont ent =" J avaScr i pt " name=" vs_def aul t Cl i ent Scr i pt " >
<met a cont ent =" ht t p: / / schemas. mi cr osof t . com/ i nt el l i sense/ i e5"
name=" vs_t ar get Schema" >
</ HEAD>
<body MS_POSI TI ONI NG=" Gr i dLayout " >
<f or mi d=" For m1" act i on=" / ?sci d=Upl oadFi l e. aspx& f p=1" met hod=" post "
encType=" mul t i par t / f or m- dat a" r unat =" ser ver " >
<asp: l abel i d=" Label 2" st yl e=" Z- I NDEX: 108; LEFT: 24px; POSI TI ON:
absol ut e; TOP: 16px" r unat =" ser ver " Font - Si ze=" Lar ge" Wi dt h=" 592px"
Font - Bol d=" Tr ue" For eCol or =" Bl ue" >J pg and Png Fi l e Pr ocess ( Edge
Det ect i on)
</ asp: l abel >
Jenaro C. Paz
________________________________________________________________________
382
<di v i d=" Header " r unat =" ser ver " >
absol ut e; TOP: 48px" r unat =" ser ver " Font - Bol d=" Tr ue"
For eCol or =" Medi umPur pl e" >I mage f i l e t o upl oad t o t he ser ver :
</ asp: l abel >
<I NPUT i d=" oFi l e" st yl e=" Z- I NDEX: 101; LEFT: 256px; WI DTH: 300px;
POSI TI ON: absol ut e; TOP: 48px; HEI GHT: 22px" t ype=" f i l e"
si ze=" 68" name=" oFi l e" r unat =" ser ver " >
<asp: but t on i d=" bt nUpl oad" st yl e=" Z- I NDEX: 117; LEFT: 584px; POSI TI ON:
absol ut e; TOP: 48px" r unat =" ser ver " t ext =" Upl oad" >
</ asp: but t on>
</ di v>
<asp: l abel i d=" l bl Upl oadResul t " st yl e=" Z- I NDEX: 104; LEFT: 24px;
POSI TI ON: absol ut e; TOP: 80px" For eCol or =" Red" Vi si bl e=" Fal se"
Runat =" ser ver " >
</ asp: l abel >
absol ut e; TOP: 120px" r unat =" ser ver " Font - Si ze=" Medi um"
Font - Bol d=" Tr ue" For eCol or =" Medi umPur pl e" Vi si bl e=" Fal se" >Scal e
t o speci f i c si ze:
</ asp: l abel >
absol ut e; TOP: 96px" r unat =" ser ver " Font - Si ze=" XX- Lar ge"
Vi si bl e=" Fal se" Hei ght =" 64px" >{</ asp: l abel >
absol ut e; TOP: 104px" r unat =" ser ver " Font - Bol d=" Tr ue"
Vi si bl e=" Fal se" >Wi dt h: </ asp: l abel ><asp: l abel i d=" Label 5"
st yl e=" Z- I NDEX: 111; LEFT: 232px; POSI TI ON: absol ut e; TOP: 136px"
r unat =" ser ver " Font - Bol d=" Tr ue" vi si bl e=" Fal se" >Hei ght : </ asp: l abel >
<asp: t ext box i d=" t xt Wi dt h" st yl e=" Z- I NDEX: 112; LEFT: 288px; POSI TI ON:
absol ut e; TOP: 104px" r unat =" ser ver " Wi dt h=" 64px"
Vi si bl e=" Fal se" ></ asp: t ext box>
<asp: t ext box i d=" t xt Hei ght " st yl e=" Z- I NDEX: 113; LEFT: 288px; POSI TI ON:
absol ut e; TOP: 136px" r unat =" ser ver " Wi dt h=" 64px"
Vi si bl e=" Fal se" ></ asp: t ext box>
<asp: but t on i d=" bt nPr ocess" st yl e=" Z- I NDEX: 106; LEFT: 576px; POSI TI ON:
absol ut e; TOP: 120px" r unat =" ser ver " Vi si bl e=" Fal se"
Text =" Pr ocess" >
</ asp: but t on>
</ f or m>
<asp: i mage i d=" I mage1" st yl e=" Z- I NDEX: 105; LEFT: 24px; POSI TI ON:
absol ut e; TOP: 168px" r unat =" ser ver " Vi si bl e=" Fal se" >
</ asp: i mage>
<asp: i mage i d=" I mage2" st yl e=" Z- I NDEX: 107; LEFT: 24px; POSI TI ON:
absol ut e; TOP: 168px" r unat =" ser ver " Vi si bl e=" Fal se" >
</ asp: i mage>
</ body>
</ HTML>

UploadEdgeDetection.aspx.cs

usi ng Syst em;
usi ng Syst em. Col l ect i ons;
usi ng Syst em. Component Model ;
usi ng Syst em. Dat a;
________________________________________________________________________
383
usi ng Syst em. Dr awi ng;
usi ng Syst em. Dr awi ng. Dr awi ng2D;
usi ng Syst em. Dr awi ng. I magi ng;
usi ng Syst em. Web;
usi ng Syst em. Web. Sessi onSt at e;
usi ng Syst em. Web. UI ;
usi ng Syst em. Web. UI . WebCont r ol s;
usi ng Syst em. Web. UI . Ht ml Cont r ol s;
usi ng Syst em. I O ;
usi ng Syst em. I O. I sol at edSt or age;

namespace J CPGr aphi cs
{
/ / / <summar y>
/ / / Summar y descr i pt i on f or WebFor m1.
/ / / </ summar y>
publ i c cl ass Upl oadEdgeDet ect i on : Syst em. Web. UI . Page
{
publ i c st at i c st r i ng st r Fi l eName;
publ i c st at i c st r i ng st r Fi l ePat h;
publ i c st at i c st r i ng newSt r Fi l ePat h;
publ i c st at i c st r i ng st r Fol der ;
publ i c st at i c st r i ng mi meType;
publ i c st at i c st r i ng f i l eExt ;
pr ot ect ed Syst em. Web. UI . WebCont r ol s. But t on bt nUpl oad;
pr ot ect ed Syst em. Web. UI . WebCont r ol s. Label l bl Upl oadResul t ;
pr ot ect ed Syst em. Web. UI . WebCont r ol s. Label Label 1;
pr ot ect ed Syst em. Web. UI . WebCont r ol s. I mage I mage1;
pr ot ect ed Syst em. Web. UI . WebCont r ol s. But t on bt nPr ocess;
pr ot ect ed Syst em. Web. UI . WebCont r ol s. I mage I mage2;
pr ot ect ed Syst em. Web. UI . WebCont r ol s. Text Box t xt Wi dt h;
pr ot ect ed Syst em. Web. UI . WebCont r ol s. Text Box t xt Hei ght ;
pr ot ect ed Syst em. Web. UI . Ht ml Cont r ol s. Ht ml Gener i cCont r ol Header ;
pr ot ect ed Syst em. Web. UI . Ht ml Cont r ol s. Ht ml I nput Fi l e oFi l e;

pr i vat e voi d Page_Load( obj ect sender , Syst em. Event Ar gs e)
{
i f ( ! I sPost Back)
{
Fi l e. Del et e ( " C: / TEMP/ I mage01. J PG" ) ;
Fi l e. Del et e ( " C: / TEMP/ I mage02. J PG" ) ;
Fi l e. Del et e ( " C: / TEMP/ I mage01. PNG" ) ;
Fi l e. Del et e ( " C: / TEMP/ I mage02. PNG" ) ;
}
}

#r egi on Web For mDesi gner gener at ed code
over r i de pr ot ect ed voi d OnI ni t ( Event Ar gs e)
{
/ /
/ / CODEGEN: Thi s cal l i s r equi r ed by t he ASP. NET Web For m
Desi gner .
Jenaro C. Paz
________________________________________________________________________
384
/ /
I ni t i al i zeComponent ( ) ;
base. OnI ni t ( e) ;
}

/ / / <summar y>
/ / / Requi r ed met hod f or Desi gner suppor t - do not modi f y
/ / / t he cont ent s of t hi s met hod wi t h t he code edi t or .
/ / / </ summar y>
pr i vat e voi d I ni t i al i zeComponent ( )
{
t hi s. bt nUpl oad. Cl i ck += new
Syst em. Event Handl er ( t hi s. bt nUpl oad_Cl i ck) ;
t hi s. bt nPr ocess. Cl i ck += new
Syst em. Event Handl er ( t hi s. bt nPr ocess_Cl i ck) ;
t hi s. Load += new Syst em. Event Handl er ( t hi s. Page_Load) ;
}
#endr egi on

pr i vat e voi d bt nUpl oad_Cl i ck( obj ect sender , Syst em. Event Ar gs e)
{
i f ( oFi l e. Val ue == " " )
{
l bl Upl oadResul t . Text = " Cl i ck ' Br owse' t o sel ect t he f i l e
t o upl oad. " ;
}
el se
{
st r Fol der = " C: \ \ TEMP\ \ " ;
/ / Ret r i eve t he name of t he f i l e t hat i s post ed.
st r Fi l eName = oFi l e. Post edFi l e. Fi l eName;
/ / Ret r i eve t he MI ME Type of t he f i l e t hat i s post ed.
mi meType =oFi l e. Post edFi l e. Cont ent Type;
i f ( mi meType ! =" i mage/ pj peg" && mi meType ! =" i mage/ x- png" )
{
l bl Upl oadResul t . Text = st r Fi l eName + " i s not a val i d i mage
Fi l e! " ;
}
el se
{
/ / J ust t ake t he name of t he Fi l e
st r Fi l eName = Pat h. Get Fi l eName( st r Fi l eName) ;

i f ( ! Di r ect or y. Exi st s( st r Fol der ) )
{
Di r ect or y. Cr eat eDi r ect or y( st r Fol der ) ;
}

st r Fi l ePat h = st r Fol der + st r Fi l eName;

i f ( Fi l e. Exi st s( st r Fi l ePat h) )
{
l bl Upl oadResul t . Text = st r Fi l eName + " al r eady exi st s on
t he ser ver ! " ;
/ / l bl Upl oadResul t . Vi si bl e = t r ue;
}
el se
________________________________________________________________________
385
{
i f ( mi meType==" i mage/ pj peg" )
{
newSt r Fi l ePat h=st r Fol der +" I mage01. j pg" ;
}
i f ( mi meType==" i mage/ x- png" )
{
newSt r Fi l ePat h=st r Fol der +" I mage01. png" ;
}
oFi l e. Post edFi l e. SaveAs( newSt r Fi l ePat h) ;
l bl Upl oadResul t . Text = st r Fi l eName + " has been
successf ul l y upl oaded. " ;
I mage1. I mageUr l =newSt r Fi l ePat h;
I mage1. Vi si bl e=t r ue;
bt nPr ocess. Vi si bl e =t r ue;
Label 3. Vi si bl e=t r ue;
t xt Wi dt h. Vi si bl e =t r ue;
t xt Hei ght . Vi si bl e =t r ue;
Header . Vi si bl e =f al se;
Bi t map cur I mage =new Bi t map( newSt r Fi l ePat h) ;
t xt Wi dt h. Text =" " +cur I mage. Wi dt h ;
t xt Hei ght . Text =" " +cur I mage. Hei ght ;
}
}

}
l bl Upl oadResul t . Vi si bl e = t r ue;
}

pr i vat e voi d bt nPr ocess_Cl i ck( obj ect sender , Syst em. Event Ar gs e)
{
bt nPr ocess. Vi si bl e =f al se;
i nt w1= UI nt 16. Par se( t xt Wi dt h. Text ) ;
i nt h1= UI nt 16. Par se( t xt Hei ght . Text ) ;
Bi t map upl oadI mage =new Bi t map( newSt r Fi l ePat h) ;

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
upl oadI mage=gI mage. EdgeDet ect 1( upl oadI mage, 50) ;
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
i f ( mi meType==" i mage/ pj peg" )
{
newSt r Fi l ePat h=st r Fol der +" I mage02. j pg" ;
upl oadI mage. Save( newSt r Fi l ePat h, I mageFor mat . J peg) ;
}
i f ( mi meType==" i mage/ x- png" )
{
newSt r Fi l ePat h=st r Fol der +" I mage02. png" ;
upl oadI mage. Save( newSt r Fi l ePat h, I mageFor mat . Png) ;
}

I mage2. I mageUr l =newSt r Fi l ePat h;
I mage2. Vi si bl e=t r ue;
I mage1. Vi si bl e=f al se;
Jenaro C. Paz
________________________________________________________________________
386
}

}
}

Una vez que el usuario selecciona una imagen de su computadora, sta es enviada al
servidor y al accionar el botn para procesarla se obtiene un resultado como el mostrado
a continuacin.

Figura 8.5. EdgeDetect

8.2.1.2 Escala de grises (grayscale)

En el espacio de colores, los vectores en la direccin del vector (1, 1, 1) representan
diferentes tonalidades de gris. As, cualquier pxel (r, g, b) de una imagen, proyectado
sobre este vector nos dar su contribucin gris a una nueva imagen que formemos con
todas las proyecciones de los pixeles originales.

Figura 8.6. Espacio vectorial de Colores

Del lgebra de vectores sabemos que el producto escalar:
________________________________________________________________________
387

Que nos da al calcular las magnitudes de los vectores:

Pero como la proyeccin de C en la direccin de u es:

Entonces:

El mayor valor que puede tomar esta expresin es 255 !3 y como debemos cuidar que la
magnitud de esta expresin nunca rebase 255 debemos normalizarla multiplicando por
1/ !3

As:

Es la proyeccin normalizada de un pxel en la direccin de los grises.

Teniendo esto en mente, haremos un mtodo para recorrer todos los pixeles de una
imagen para generar su componente gris.

gImage.GrayscaleNormalized

publ i c st at i c Bi t map Gr ayScal eNor mal i zed( Bi t map cur I mage)
{
Bi t mapDat a i mgDat a = cur I mage. LockBi t s( new Rect angl e( 0,
0, cur I mage. Wi dt h, cur I mage. Hei ght ) ,
I mageLockMode. ReadWr i t e, Pi xel For mat . For mat 24bppRgb) ;
i nt st r i de = i mgDat a. St r i de;
Syst em. I nt Pt r Scan0 = i mgDat a. Scan0;
unsaf e
{
byt e * p = ( byt e *) ( voi d *) Scan0;
byt e byt eBl ue, byt eGr een, byt eRed;
i nt nOf f set = st r i de - cur I mage. Wi dt h *3;
i nt nHei ght = cur I mage. Hei ght ;
i nt nWi dt h= cur I mage. Wi dt h;
f or ( i nt y = 0; y < nHei ght ; y++)
Jenaro C. Paz
________________________________________________________________________
388
{
f or ( i nt x = 0; x < nWi dt h; x++)
{
byt eBl ue = p[ 0] ;
byt eGr een = p[ 1] ;
byt eRed = p[ 2] ;
p[ 0] = p[ 1] =p[ 2] =( ( byt e) ( byt eRed + byt eGr een + byt eBl ue) ) / 3;

p+=3;
}
p+=nOf f set ;
}
}
cur I mage. Unl ockBi t s ( i mgDat a) ;
}

Si en la forma Web que utilizamos en el ejercicio anterior en vez de

upl oadI mage=gI mage. EdgeDet ect 1( upl oadI mage, 50) ;

utilizamos

upl oadI mage=gI mage. Gr ayscal eNor mal i zed( upl oadI mage) ;

para procesar una imagen a color obtendremos una nueva imagen en gris como la
mostrada a continuacin.

Figura 8.7. GrayscaleNormalized

8.2.1.3 Inversin

El valor mas grande que puede tomar un color es 255 y el mas pequeo 0, entonces si
deseamos invertir las contribuciones de los diferentes pixeles a la formacin de una
________________________________________________________________________
389
imagen, debemos restar su color de 255 y esta diferencia tomarla como la contribucin al
color de la nueva imagen.

En la figura 8.8 se observa una grfica entre la seal de entrada y la de salida en el caso
de la inversin.

Figura 8.8. Frmula para la Inversin de Colores

imagen y generaremos su correspondiente imagen invertida.

gImage.Invert

publ i c st at i c Bi t map I nver t ( Bi t map cur I mage)
{
Bi t mapDat a i mgDat a = cur I mage. LockBi t s( new
Rect angl e( 0, 0, cur I mage. Wi dt h, cur I mage. Hei ght ) ,
I mageLockMode. ReadWr i t e, Pi xel For mat . For mat 24bppRgb) ;
unsaf e
{
byt e *p = ( byt e *) Scan0;
i nt nWi dt h= cur I mage. Wi dt h *3;
i nt nOf f set = st r i de - nWi dt h;
f or ( i nt y = 0; y < nHei ght ; y++)
{
f or ( i nt x = 0; x < nWi dt h; x++)
{
p[ 0] = ( byt e) ( 255- p[ 0] ) ;
p++;
}
p+=nOf f set ;
}
}
Jenaro C. Paz
________________________________________________________________________
390
cur I mage. Unl ockBi t s ( i mgDat a) ;
}


upl oadI mage=gI mage. Gr ayscal eNor mal i zed( upl oadI mage) ;

utilizamos

upl oadI mage=gI mage. I nver t ( upl oadI mage) ;

para procesar una imagen a color obtendremos una nueva imagen invertida como la

Figura 8.9. Invert

8.2.1.4 Brillo

Aumentar el brillo de una imagen consiste en sumar o restar una constante a los colores
que constituyen un pxel, cuidando siempre de nunca rebasar los lmites 0 y 255. Si
observamos la siguiente figura, aumentar o disminuir el brillo en una imagen consiste en
aumentar o disminuir la ordenada al origen de la lnea recta con pendiente a 45 grados
que representa los grises.

________________________________________________________________________
391

Figura 8.10. Aumento o disminucin de Brillo

imagen y generaremos su correspondiente imagen donde hemos aumentado o disminuido
el brillo

gImage.Brightness

publ i c st at i c Bi t map Br i ght ness( Bi t map cur I mage, i nt nBr i ght ness)
{
i f ( nBr i ght ness < - 255 ) nBr i ght ness = - 10;
i f ( nBr i ght ness > 255 ) nBr i ght ness = 10;
Bi t mapDat a i mgDat a = cur I mage. LockBi t s( new Rect angl e( 0, 0,

i nt [ ] Br i ght _t r ansf or m= new i nt [ 256] ;
f or ( i nt i =0; i <256; i ++)
{
Br i ght _t r ansf or m[ i ] =i +nBr i ght ness;

i f ( Br i ght _t r ansf or m[ i ] > 255) Br i ght _t r ansf or m[ i ] =255;
i f ( Br i ght _t r ansf or m[ i ] < 0 ) Br i ght _t r ansf or m[ i ] =0;
}

unsaf e
{
i nt nOf f set = st r i de - cur I mage. Wi dt h*3;
i nt nWi dt h = cur I mage. Wi dt h * 3;
f or ( i nt y=0; y<nHei ght ; y++)
{
f or ( i nt x=0; x < nWi dt h; x++ )
Jenaro C. Paz
________________________________________________________________________
392
{
p[ 0] = ( byt e) Br i ght _t r ansf or m[ p[ 0] ] ;
++p;
}
p += nOf f set ;
}
}

cur I mage. Unl ockBi t s( i mgDat a) ;
}

.

upl oadI mage=gI mage. I nver t ( upl oadI mage) ;

utilizamos

upl oadI mage=gI mage. Br i ght ness( upl oadI mage, 60) ;

para procesar una imagen a color obtendremos una nueva imagen con ms brillo como la

Figura 8.11. Brightness

8.2.1.5 Contraste

Si observamos la siguiente figura, aumentar o disminuir el contraste en una imagen
consiste en aumentar o disminuir la pendiente de la lnea recta con pendiente a 45 grados
que representa los grises, cuidando siempre de nunca rebasar los lmites 0 y 255.

________________________________________________________________________
393

Figura 8.12. Aumento o disminucin de Contraste

As, la frmula que tenemos que aplicar en este tipo de transformacin tiene la forma
siguiente:

Ntese que esta frmula representa una familia de rectas que pasan por el punto
(128,128) con diferentes pendientes.

Teniendo lo anterior en mente, haremos un mtodo para recorrer todos los pixeles de una
el contraste.

gImage.Contrast

publ i c st at i c Bi t map Cont r ast ( Bi t map cur I mage, doubl e Cont r ast Angl e)
{
doubl e cval ue = 0;
doubl e cont r ast = Mat h. Tan( Cont r ast Angl e*Mat h. PI / 180. 0) ;

i nt nr ed, ngr een, nbl ue;
i nt nWi dt h = cur I mage. Wi dt h;

Bi t mapDat a i mgDat a = cur I mage. LockBi t s( new Rect angl e( 0, 0, nWi dt h,
nHei ght ) , I mageLockMode. ReadWr i t e, Pi xel For mat . For mat 24bppRgb) ;
unsaf e
{
f or ( i nt y=0; y<nHei ght ; ++y)
Jenaro C. Paz
________________________________________________________________________
394
{
f or ( i nt x=0; x < nWi dt h; ++x )
{
nbl ue = p[ 0] ;
ngr een = p[ 1] ;
nr ed = p[ 2] ;
cval ue = 128 +( nbl ue- 128) *cont r ast ;
i f ( cval ue < 0) cval ue = 0;
i f ( cval ue > 255) cval ue = 255;
p[ 0] = ( byt e) cval ue;
cval ue = 128+( ngr een - 128) *cont r ast ;
cval ue = 128+( nr ed- 128) *cont r ast ;

p += 3;
}
p += nOf f set ;
}
}

}


upl oadI mage=gI mage. Br i t hness( upl oadI mage, 60) ;

utilizamos
upl oadI mage=gI mage. Cont r ast ( upl oadI mage, 80) ;

para procesar una imagen a color obtendremos una nueva imagen donde el contraste se ha
aumentado considerablemente.

Figura 8.13. Contrast
________________________________________________________________________
395

8.2.1.6 Modificacin de Colores

En esta seccin estamos interesados en variar para cada uno de los pixeles que
constituyen una imagen, las contribuciones en rojo, verde y azul en cantidades constantes
de tal manera que podamos resaltar los rojos y disminuir los azules por ejemplo.

Teniendo lo anterior en cuenta, haremos un mtodo para recorrer todos los pixeles de una
cada uno de los colores en cierta cantidad.

gImage.ModifyColor

publ i c st at i c Bi t map Modi f yCol or ( Bi t map cur I mage,
i nt nr ed, i nt ngr een, i nt nbl ue)
{
i f ( nr ed < - 255 | | nr ed > 255) nr ed=0;
i f ( ngr een < - 255 | | ngr een > 255) ngr een=0;
i f ( nbl ue < - 255 | | nbl ue > 255) nbl ue=0;

i nt nWi dt h = cur I mage. Wi dt h;

nWi dt h, nHei ght ) , I mageLockMode. ReadWr i t e,


unsaf e
{
i nt nPi xel ;

{
{
nPi xel = p[ 2] + nr ed;
nPi xel = Mat h. Max( nPi xel , 0) ;
p[ 2] = ( byt e) Mat h. Mi n( 255, nPi xel ) ;
nPi xel = p[ 1] + ngr een;
nPi xel = p[ 0] + nbl ue;
p += 3;
}
Jenaro C. Paz
________________________________________________________________________
396
p += nOf f set ;
}
}
}


upl oadI mage=gI mage. Cont r ast ( upl oadI mage, 80) ;

utilizamos

upl oadI mage=gI mage. Modi f yCol or ( upl oadI mage, 10, - 10, 20) ;

para procesar una imagen a color obtendremos una nueva imagen donde hemos
modificado los colores rojos en 10 unidades, los colores verdes en -10 unidades y los
colores azules en 20 unidades.

Figura 8.14. Modificacin de Color

________________________________________________________________________
397
8.2.1.7 Correccin Gamma

Es el ajuste de los valores de intensidad de una imagen (vagamente hablando, una
combinacin del brillo y el contraste) con el objetivo de compensar las variaciones de los
dispositivos de salida. Por ejemplo, las imgenes desplegadas en una Macintosh deben
ser corregidas de forma Gamma para que luzcan de la misma manera que en una PC y
viceversa.

La frmula que se utiliza para hacer esta correccin viene dada por:

Que al ser tabulada para diferentes valores de Gamma nos produce una grfica como la
siguiente:

Figura 8.15. Concepto de correccin Gamma

Si observamos esta grfica lo que podemos concluir es lo siguiente:

Para gamma =1 no hay ninguna correccin
Para gamma >1 hay una gran correccin en el contraste para valores pequeos
del color de entrada mientras que una pequea correccin en el contraste para
valores grandes. El brillo aumenta ms para valores intermedios del color de
entrada.
Para gamma < 1 hay una pequea correccin en el contraste para valores
pequeos del color de entrada mientras que una gran correccin en el contraste
para valores grandes. El brillo disminuye ms para valores intermedios del color
de entrada.

Teniendo lo anterior en cuenta, haremos un mtodo para recorrer todos los pixeles de una
su gamma en cierta cantidad.

Jenaro C. Paz
________________________________________________________________________
398
gImage.Gamma

publ i c st at i c Bi t map Gamma( Bi t map cur I mage, doubl e g_r ed, doubl e
g_gr een, doubl e g_bl ue)
{
i f ( g_r ed < . 2 | | g_r ed > 5) g_r ed=1. 0;
i f ( g_gr een < . 2 | | g_gr een > 5) g_gr een=1. 0;
i f ( g_bl ue < . 2 | | g_bl ue > 5) g_bl ue=1. 0;

byt e [ ] r edGamma = new byt e [ 256] ;
byt e [ ] gr eenGamma = new byt e [ 256] ;
byt e [ ] bl ueGamma = new byt e [ 256] ;

f or ( i nt i = 0; i < 256; ++i )
{
r edGamma[ i ] = ( byt e) Mat h. Mi n( 255, ( i nt ) ( ( 255. 0 *
Mat h. Pow( i / 255. 0, 1. 0/ g_r ed) ) + 0. 5) ) ;
gr eenGamma[ i ] = ( byt e) Mat h. Mi n( 255, ( i nt ) ( ( 255. 0 *
Mat h. Pow( i / 255. 0, 1. 0/ g_gr een) ) + 0. 5) ) ;
bl ueGamma[ i ] = ( byt e) Mat h. Mi n( 255, ( i nt ) ( ( 255. 0 *
Mat h. Pow( i / 255. 0, 1. 0/ g_bl ue) ) + 0. 5) ) ;
}

i nt nWi dt h=cur I mage. Wi dt h;

nWi dt h, nHei ght ) , I mageLockMode. ReadWr i t e,



unsaf e
{
{
{
p[ 2] = r edGamma[ p[ 2] ] ;
p[ 1] = gr eenGamma[ p[ 1] ] ;
p[ 0] = bl ueGamma[ p[ 0] ] ;
p += 3;
}
p += nOf f set ;
}
}
}

________________________________________________________________________
399

upl oadI mage=gI mage. Modi f yCol or ( upl oadI mage, 10, - 10, 20) ;

utilizamos

upl oadI mage=gI mage. Gamma( upl oadI mage, 1. 2, 0. 8, 1. 4) ;

para procesar una imagen a color obtendremos una nueva imagen donde hemos
modificado el coeficiente Gamma en los colores rojos en 1.2 unidades, en los colores
verdes en 0.8 unidades y en los colores azules en 1.4 unidades.

O bien esta otra donde hemos modificado el coeficiente Gamma en los colores rojo
verde y azul en 0.8 unidades.

Figura 8.16. Modificando Gamma

Jenaro C. Paz
________________________________________________________________________
400
8.2.2 Modificacin de Imagen
En esta seccin cubriremos algunas de las tcnicas ms conocidas que estn relacionadas
con la modificacin de imgenes al manipular sus pixeles cambindolos de posicin.

8.2.2.1 Inversin de imagen (Flip)
Esta modificacin se lleva a cabo moviendo un pxel de la columnai rengln j a la misma
columnai rengln Height - (j+1).

Figura 8.17. Concepto de la Inversin vertical

A continuacin se presenta un mtodo para recorrer todos los pixeles de una imagen
invirtiendolos verticalmente, hace uso de los mtodos GetPixel y SetPixel de la Clase
Bitmap.

gImage.Flip

publ i c st at i c Bi t map Fl i p( Bi t map cur I mage)
{
Bi t map bTemp = ( Bi t map) cur I mage. Cl one( ) ;
cur I mage = new Bi t map ( bTemp. Wi dt h, bTemp. Hei ght ,
bTemp. Pi xel For mat ) ;
i nt nWi dt h = bTemp. Wi dt h;
i nt nHei ght = bTemp. Hei ght ;

f or ( i nt x=0; x < nWi dt h; x++)
f or ( i nt y=0; y < nHei ght ; y++)
{
cur I mage. Set Pi xel ( x, y, bTemp. Get Pi xel ( x, nHei ght - ( y+1) ) ) ;
}
}

________________________________________________________________________
401

upl oadI mage=gI mage. Gamma( upl oadI mage, 1. 2, 0. 8, 1. 4) ;

utilizamos

upl oadI mage=gI mage. Fl i p( upl oadI mage) ;

para procesar una imagen a color obtendremos una nueva imagen donde la hemos
invertido.

Figura 8.18. Inversin vertical de imagen

8.2.2.2 Reflexion de Imagen (Mirror)

Esta modificacin se lleva a cabo moviendo un pxel del rengln j, columna i al mismo
rengln j, columna Width-(i+1).

Jenaro C. Paz
________________________________________________________________________
402

Figura 8.19. Concepto de la Inversin horizontal

A continuacin se presenta un mtodo para recorrer todos los pixeles de una imagen
invirtiendolos horizontalmente, tambin hace uso de los mtodos GetPixel y SetPixel de
la Clase Bitmap.

gImage.Mirror

publ i c st at i c Bi t map Mi r r or ( Bi t map cur I mage)
{

cur I mage = new Bi t map ( bTemp. Wi dt h, bTemp. Hei ght ,
i nt nWi dt h = bTemp. Wi dt h;
i nt nHei ght = bTemp. Hei ght ;

f or ( i nt x=0; x < nWi dt h; x++)
{
cur I mage. Set Pi xel ( x, y, bTemp. Get Pi xel ( nWi dt h- ( x+1) , y) ) ;
}

}


upl oadI mage=gI mage. Fl i p( upl oadI mage) ;

utilizamos

upl oadI mage=gI mage. Mi r r or ( upl oadI mage) ;

para procesar una imagen a color obtendremos una nueva imagen espejo de la original
________________________________________________________________________
403

Figura 8.20. Inversin horizontal de imagen

8.2.2.3 Escalamiento (Scale)
Esta modificacin sirve para alterar el tamao de una imagen, copiando solamente
algunos pixeles de la imagen original en el caso de reduccin o bien calculando colores
intermedios en el caso de amplificaciones.

A continuacin un mtodo que permite hacer lo anteriormente expuesto.

gImage.Scale

publ i c st at i c Bi t map Scal e( Bi t map cur I mage, i nt newWi dt h, i nt
newHei ght , bool bReduce)
{

cur I mage = new Bi t map ( newWi dt h, newHei ght , bTemp. Pi xel For mat ) ;

doubl e nXf act or =( doubl e) bTemp. Wi dt h / ( doubl e) newWi dt h;
doubl e nYf act or =( doubl e) bTemp. Hei ght / ( doubl e) newHei ght ;

i f ( bReduce)
{
f or ( i nt x=0; x<cur I mage. Wi dt h ; x++)
{
f or ( i nt y=0; y<cur I mage. Hei ght ; y++)

cur I mage. Set Pi xel ( x, y, bTemp. Get Pi xel ( ( i nt ) ( Mat h. Fl oor ( x*nXf act or ) ) ,
( i nt ) ( Mat h. Fl oor ( y*nYf act or ) ) ) ) ;
}
}
el se
{
doubl e f _X, f _Y, di f f X, di f f Y;
i nt up_X, up_Y, down_X, down_Y;
Col or col or 1 = new Col or ( ) ;
Jenaro C. Paz
________________________________________________________________________
404
byt e r ed, gr een, bl ue;
byt e b1, b2;
f or ( i nt x = 0; x < cur I mage. Wi dt h; ++x)
f or ( i nt y = 0; y < cur I mage. Hei ght ; ++y)
{
down_X = ( i nt ) Mat h. Fl oor ( x * nXf act or ) ;
down_Y = ( i nt ) Mat h. Fl oor ( y * nYf act or ) ;
up_X = down_X + 1;
i f ( up_X >= bTemp. Wi dt h) up_X = down_X;
up_Y = down_Y + 1;
i f ( up_Y >= bTemp. Hei ght ) up_Y = down_Y;
f _X = x * nXf act or - down_X;
f _Y = y * nYf act or - down_Y;
di f f X = 1. 0 - f _X;
di f f Y = 1. 0 - f _Y;
col or 1 = bTemp. Get Pi xel ( down_X, down_Y) ;
col or 2 = bTemp. Get Pi xel ( up_X, down_Y) ;
col or 3 = bTemp. Get Pi xel ( down_X, up_Y) ;
col or 4 = bTemp. Get Pi xel ( up_X, up_Y) ;

b1 = ( byt e) ( di f f X * col or 1. B + f _X * col or 2. B) ;
b2 = ( byt e) ( di f f X * col or 3. B + f _X * col or 4. B) ;
bl ue = ( byt e) ( di f f Y * ( doubl e) ( b1) + f _Y *
( doubl e) ( b2) ) ;

b1 = ( byt e) ( di f f X * col or 1. G + f _X * col or 2. G) ;
b2 = ( byt e) ( di f f X * col or 3. G + f _X * col or 4. G) ;
gr een = ( byt e) ( di f f Y * ( doubl e) ( b1) + f _Y *
( doubl e) ( b2) ) ;

b1 = ( byt e) ( di f f X * col or 1. R + f _X * col or 2. R) ;
b2 = ( byt e) ( di f f X * col or 3. R + f _X * col or 4. R) ;
r ed = ( byt e) ( di f f Y * ( doubl e) ( b1) + f _Y *
( doubl e) ( b2) ) ;

cur I mage. Set Pi xel ( x, y, Syst em. Dr awi ng. Col or . Fr omAr gb( 255,
r ed, gr een, bl ue) ) ;
}
}
}


upl oadI mage=gI mage. Mi r r or ( upl oadI mage) ;

utilizamos

upl oadI mage=gI mage. Scal e( upl oadI mage, 100, 67, t r ue) ;

para procesar una imagen a color obtendremos una nueva imagen reducida de la original

________________________________________________________________________
405

Figura 8.21. Escalamiento

8.2.2.4 Rotacin de Imagen
Para llevar a cabo la rotacin de una imagen es necesario llevar a cabo los pasos
siguientes:
Generar un nuevo lienzo, pixelImage, con forma de cuadrado donde la
dimensin del lado sea igual a la diagonal del lienzo original, con la finalidad de
que la imagen pueda girar con libertad en su centro, pCenterOfCanvas, sin que
sea recortado en sus lados.
Generar un nuevo rectngulo, toCenterImage, centrado en el cuadrado.
Crear una Matriz para llevar a cabo la rotacin de la imagen en un ngulo
determinado.

A continuacin se presenta un mtodo que hace lo anterior.

gImage.Rotate

publ i c st at i c Bi t map Rot at e( Bi t map cur I mage, i nt angl e)
{
i nt newCanvasSi ze=( i nt ) ( Mat h. Sqr t ( Mat h. Pow
( cur I mage. Wi dt h, 2. 0) +Mat h. Pow( cur I mage. Hei ght , 2. 0) ) ) ;
Bi t map pi xel I mage = new Bi t map( newCanvasSi ze, newCanvasSi ze) ;

Gr aphi cs g = Gr aphi cs. Fr omI mage( pi xel I mage) ;
g. Cl ear ( Syst em. Dr awi ng. Col or . Whi t e) ;
r ae z X = new r ae z( ) ;
Rect angl e t oCent er I mage = new Rect angl e(
( newCanvasSi ze- cur I mage. Wi dt h) / 2,
( newCanvasSi ze- cur I mage. Hei ght ) / 2,
cur I mage. Wi dt h ,
cur I mage. Hei ght ) ;
Poi nt pCent er Of Canvas = new Poi nt ( newCanvasSi ze/ 2,
newCanvasSi ze/ 2) ;
X. Rot at eAt ( angl e, pCent er Of Canvas, Mat r i xOr der . Append) ;
g. Tr ansf or m=X;
g. Dr awI mage( cur I mage, t oCent er I mage) ;
r et ur n pi xel I mage;

}
Jenaro C. Paz
________________________________________________________________________
406


upl oadI mage=gI mage. Scal e( upl oadI mage, 100, 67, r ae) ;

utilizamos

upl oadI mage=gI mage. Rot at e( upl oadI mage, 30) ;

para procesar una imagen a color obtendremos una nueva imagen donde hemos girado la
imagen original en 30 grados en sentido de las manecillas del reloj.

Figura 8.22. Rotacin positiva de imagen

8.2.2.5 Perspectiva Horizontal

Esta transformacin consiste en un mapeo entre los puntos interiores de un rectngulo de
ancho w1 y altura h1 y los de un trapecio con bases h1 y h1-2*a1 y altura w1-b1 como
se muestra en la siguiente figura.

________________________________________________________________________
407

Figura 8.23. Generacin de Perspectiva horizontal

Aqu b1 es proporcional a un porcentaje del ancho de la imagen original y a1 es la mitad
de b1. La relacin entre las Xs del rectngulo y las del trapecio esta dada por:

Y la relacin entre las Ys y Xs del rectngulo con las Ys del trapecio estn dadas por:

Para la parte superior del trapecio y por:

Para la parte inferior del trapecio.

Cuando el porcentaje en la perspectiva es negativo tenemos:

Y la relacin entre las Ys y Xs del rectngulo con las Ys del trapecio estn dadas por:

Para la parte superior del trapecio y por:

Jenaro C. Paz
________________________________________________________________________
408

Para la parte inferior del trapecio.

A continuacin se presenta un mtodo que hace uso de los algoritmos mencionados.

gImage.PerspectiveX

publ i c st at i c Bi t map Per spect i veX( Bi t map cur I mage, f l oat per cent age,
Col or bgCol or )
{

f l oat b1 = ( f l oat ) ( Mat h. Abs( per cent age*0. 007*cur I mage. Wi dt h) ) ;
f l oat a1 = b1/ 2;
cur I mage = new Bi t map ( cur I mage. Wi dt h, cur I mage. Hei ght ,
Gr aphi cs g = Gr aphi cs. Fr omI mage( cur I mage) ;
g. Cl ear ( bgCol or ) ;

i nt i mWi dt h = cur I mage. Wi dt h ;
i nt i mHei ght = cur I mage. Hei ght ;

i f ( per cent age >0)
{
f or ( i nt x=0; x<i mWi dt h ; x++)
{
i nt x2 = ( i nt ) ( x*( i mWi dt h- b1) / i mWi dt h) ;
/ / upper hal f
f or ( i nt y=0; y<i mHei ght / 2 ; y++)
{
i nt y2 =( i nt ) ( y + a1*x2/ ( i mWi dt h - b1) -
2*y*a1*x2/ ( ( i mWi dt h - b1) *i mHei ght ) ) ;
cur I mage. Set Pi xel ( x2, y2, bTemp. Get Pi xel ( x, y) ) ;
}
/ / l ower hal f
f or ( i nt y=i mHei ght / 2 ; y<i mHei ght ; y++)
{
i nt y2 =( i nt ) ( y - a1*x2/ ( i mWi dt h - b1) + 2*( i mHei ght -
y) *a1*x2/ ( ( i mWi dt h - b1) *i mHei ght ) ) ;
}
}
}
el se
{
f or ( i nt x=0; x<i mWi dt h ; x++)
{
i nt x2 = ( i nt ) ( b1+x*( i mWi dt h- b1) / i mWi dt h) ;
f or ( i nt y=0; y<i mHei ght / 2 ; y++)
{
i nt y2 =( i nt ) ( y + a1*( i mWi dt h- x2) / ( i mWi dt h - b1) -
2*y*a1*( i mWi dt h- x2) / ( ( i mWi dt h - b1) *i mHei ght ) ) ;
________________________________________________________________________
409
}
f or ( i nt y=i mHei ght / 2 ; y<i mHei ght ; y++)
{
i nt y2 =( i nt ) ( y - a1*( i mWi dt h- x2) / ( i mWi dt h - b1) +
2*( i mHei ght - y) *a1*( i mWi dt h- x2) /
( ( i mWi dt h - b1) *i mHei ght ) ) ;
}
}
}
}


upl oadI mage=gI mage. Rot at e( upl oadI mage, 30) ;

utilizamos

upl oadI mage=gI mage. Per spect i veX( upl oadI mage, 10, Col or . Whi t e) ;

para procesar una imagen a color obtendremos una nueva imagen donde hemos realizado
una perspectiva horizontal modificado la imagen original en 10 % .

Figura 8.24. Perspectiva horizontal de imagen

8.2.2.6 Perspectiva Vertical
Esta transformacin consiste en un mapeo entre los puntos interiores de un rectngulo de
ancho w1 y altura h1 y los de un trapecio con bases w1 y w1-2*b1 y altura h1-a1 como
se muestra en la siguiente figura.
Jenaro C. Paz
________________________________________________________________________
410

Figura 8.25. Generacin de Perspectiva vertical

Aqu b1 es proporcional a un porcentaje del ancho de la imagen original y a1 es el doble
de b1. La relacin entre las Ys del rectngulo y las del trapecio esta dada por:

Y la relacin entre las Xs y Ys del rectngulo con las Xs del trapecio estn dadas por:

Para la parte izquierda de la imagen y por:

Para la parte derecha.

Cuando el porcentaje en la perspectiva es negativo, la relacin entre las Ys del
rectngulo y las del trapecio esta dada por:

Y la relacin entre las Xs y Ys del rectngulo con las Xs del trapecio estn dadas por:

________________________________________________________________________
411
Para la parte izquierda de la imagen y por:

Para la parte derecha.

A continuacin se presenta un mtodo que hace uso de los algoritmos mencionados.

gImage.PerspectiveY

publ i c st at i c Bi t map Per spect i veY( Bi t map cur I mage, i col per cent age,
Col or i col or )
{

i col b1 = ( i col ) ( Mat h. Abs( per cent age*0. 005*cur I mage. Wi dt h) ) ;
i col a1 = b1*2;
cur I mage = new Bi t map ( cur I mage. Wi dt h, cur I mage. Hei ght ,
Gr aphi cs g = Gr aphi cs. Fr omI mage( cur I mage) ;
g. Smoot hi ngMode=Smoot hi ngMode. Hi ghQual i t y;
g. Cl ear ( i col or ) ;

i nt i mWi dt h = cur I mage. Wi dt h ;
i nt i mHei ght = cur I mage. Hei ght ;

i f ( per cent age >0)
{
f or ( i nt y=0; y<i mHei ght ; y++)
{
i nt y2 = ( i nt ) ( y*( i mHei ght - a1) / i mHei ght ) ;
/ / Lef t Si de
f or ( i nt x=0; x<i mWi dt h/ 2 ; x++)
{
i nt x2 =( i nt ) ( x + b1*y2/ ( i mHei ght a1) -
2*x*b1*y2/ ( ( i mHei ght a1) *i mWi dt h) ) ;
}
/ / Ri ght Si de
f or ( i nt x=i mWi dt h/ 2 ; x<i mWi dt h; x++)
{
i nt x2 =( i nt ) ( x b1*y2/ ( i mHei ght a1) + 2*( i mWi dt h-
x) *b1*y2/ ( ( i mHei ght a1) *i mWi dt h) ) ;
}
}

}
el se
{
f or ( i nt y=0; y<i mHei ght ; y++)
Jenaro C. Paz
________________________________________________________________________
412
{
i nt y2 = ( i nt ) ( a1+y*( i mHei ght - a1) / i mHei ght ) ;
f or ( i nt x=0; x<i mWi dt h/ 2 ; x++)
{
i nt x2 =( i nt ) ( x + b1*( i mHei ght - y2) / ( i mHei ght a1) -
2*x*b1*( i mHei ght - y2) / ( ( i mHei ght a1) *i mWi dt h) ) ;
}
f or ( i nt x=i mWi dt h/ 2 ; x<i mWi dt h; x++)
{
i nt x2 =( i nt ) ( x b1*( i mHei ght - y2) / ( i mHei ght a1) +
2*( i mWi dt h- x) *b1*( i mHei ght - y2) /
( ( i mHei ght a1) *i mWi dt h) ) ;
}
}
}
}


upl oadI mage=gI mage. Per spect i veX( upl oadI mage, 10, Col or . Whi t e) ;

utilizamos

upl oadI mage=gI mage. Per spect i veY( upl oadI mage, 20, Col or . Whi t e) ;

una perspectiva vertical modificado la imagen original en 20 % .

Figura 8.26. Perspectiva vertical de imagen
________________________________________________________________________
413

8.2.2.7 Inclinacin Horizontal
Esta transformacin se lleva a cabo mediante la aplicacin del mtodo DrawImage de la
clase Graphics, solamente proporcionando la imagen a transformar y un conjunto de
puntos que definen los nuevos vrtices para ella.

Figura 8.27. Concepto de inclinacin horizontal

A continuacin se presenta un mtodo que hace uso de lo anterior.

gImage.SkewHor

publ i c st at i c Bi t map SkewHor ( Bi t map cur I mage, i nt angl e)
{
i nt newCanvasWi dt h=( i nt ) ( cur I mage. Wi dt h +
cur I mage. Hei ght * Mat h. Tan( angl e*Mat h. PI / 180. 0) ) ;
Bi t map pi xel I mage = new Bi t map( newCanvasWi dt h, cur I mage. Hei ght ) ;
g. Cl ear ( Col or . Whi t e) ;
Poi nt [ ] pt s =
{
new Poi nt ( ( i nt ) ( cur I mage. Hei ght *
Mat h. Tan( angl e*Mat h. PI / 180. 0) ) , 0) ,
new Poi nt ( ( i nt ) ( cur I mage. Wi dt h + cur I mage. Hei ght *
Mat h. Tan( angl e*Mat h. PI / 180. 0) ) , 0) ,
new Poi nt ( 0, cur I mage. Hei ght )
};
g. Dr awI mage( cur I mage, pt s) ;
}


upl oadI mage=gI mage. Per spect i veY( upl oadI mage, 20, Col or . Whi t e) ;

utilizamos

Jenaro C. Paz
________________________________________________________________________
414
upl oadI mage=gI mage. SkewHor ( upl oadI mage, 30) ;

una inclinacin horizontal modificado la imagen original en un ngulo de 30 grados .

Figura 8.28. Inclinacin horizontal de imagen

8.2.2.8 Inclinacin Vertical
Esta transformacin, tambin se lleva a cabo mediante la aplicacin del mtodo
DrawImage de la clase Graphics, solamente proporcionando la imagen a transformar y
un conjunto de puntos que definen los nuevos vrtices para ella.

Figura 8.29. Concepto de inclinacin horizontal de imagen

A continuacin se presenta un Mtodo donde se utiliza el algoritmo planteado y el uso de
DrawImage.

gImage.SkewVer

publ i c st at i c Bi t map SkewVer ( Bi t map cur I mage, i nt angl e)
{
i nt newCanvasHei ght =( i nt ) ( cur I mage. Hei ght +cur I mage. Wi dt h *
________________________________________________________________________
415
Mat h. Tan( angl e*Mat h. PI / 180. 0) ) ;
Bi t map pi xel I mage = new Bi t map( cur I mage. Wi dt h , newCanvasHei ght ) ;
g. Cl ear ( Col or . Whi t e) ;
Poi nt [ ] pt s =
{
new Poi nt ( 0, 0) ,
new Poi nt ( cur I mage. Wi dt h, ( i nt ) ( cur I mage. Wi dt h *
Mat h. Tan( angl e*Mat h. PI / 180. 0) ) ) ,
new Poi nt ( 0, cur I mage. Hei ght )

};
g. Dr awI mage( cur I mage, pt s) ;
}


upl oadI mage=gI mage. SkewHor ( upl oadI mage, 30) ;

utilizamos

upl oadI mage=gI mage. SkewVer ( upl oadI mage, 30) ;

una inclinacin vertical modificado la imagen original en un ngulo de 30 grados .

Figura 8.30. Inclinacin vertical de imagen
Jenaro C. Paz
________________________________________________________________________
416
8.2.3 Generacin de efectos por Convolucin
La Convolucin es una matriz (o arreglo bidimensional) que se aplica a una imagen. Los
elementos de este arreglo son valores enteros. El resultado de esta operacin es una
imagen nueva que ha sido filtrada.

Bsicamente la Convolucin modifica el color de un pixel en funcin del color de los
pixeles circunvecinos. Para cada canal, el valor de color para cada pixel se calcula del
color original y del color de los pixeles que lo rodean.

La Convolucin se aplica multiplicando el color de un pixel y el de sus pixeles
circundantes por una matriz. Esta matriz se llama el kernel de Convolucin. El kernel se
mueve por cada uno de los pixeles de la imagen original y cada pixel que queda bajo la
matriz se multiplica por un valor de la matriz, el resultado se suma y divide despus por
un valor especfico. El resultado de esta operacin es el nuevo color del pixel que cae en
el centro de la matriz. A continuacin se presenta un ejemplo muy sencillo de un kernel
de Convolucin

1 1 1
1 4 1
1 1 1

Los kernels pueden tener tamaos arbitrarios, pero los de 3 x 3 son los ms usados en la
mayora de las situaciones (tambin debido a que son los mas rpidos), ya que solo toma
en consideracin el valor del pixel mismo y el de sus 8 vecinos. Ahora, para aplicar este
kernel a una imagen debe colocarse el kernel sobre la imagen y multiplicar los valores de
color por 1 o 4. El resultado se suma y divide por 12, en este caso (la suma de los
elementos del kernel).

A continuacin se presenta una seccin de una imagen en grises, sobre la que se aplicar
el kernel de convolucin.

La hemos escogido en grises para facilitar la explicacin, ahora bien sobre cada uno de
los pixeles de esta seccin de imagen, colocamos el valor de su color, teniendo como
entendido que por ejemplo 150 =(150, 150, 150) en sus componentes rojo, verde y azul.

________________________________________________________________________
417

Ahora colocamos el kernel sobre los pixeles de la imagen y el primer pixel que
obtenemos es el (2,2), luego al desplazarnos con el kernel a la derecha el siguiente pixel
que obtendremos ser el (2,3) y as sucesivamente.

Si se tratara de una imagen no de grises, esto mismo hay que hacer para cada una de las
tres componentes (R, V, A) que constituyen al pixel, originando 9 multiplicaciones 8
sumas y una divisin por un factor de tres para cada uno de los pixeles de la imagen que
se vayan a procesar.

Por ejemplo si contamos con una imagen de 512 x 384 pixeles hay que realizar alrededor
de 10. 5 millones de operaciones para obtener la imagen filtrada. Si nos fijamos bien, los
pixeles de la orilla no pueden ser procesados porque no cuentan con todos sus vecinos
para aplicar el algoritmo entonces se tienen que desechar.

A continuacin se presenta un mtodo que multiplica una imagen por una matriz de
Convolucin de 3 x 3

Jenaro C. Paz
________________________________________________________________________
418
gImage.DoConvolution

publ i c st at i c Bi t map DoConvol ut i on3x3( Bi t map cur I mage, ConvMat r i x
conMat )
{
i f ( conMat . Fact or ==0 ) conMat . Fact or =1;

Bi t map bCopy = ( Bi t map) cur I mage. Cl one( ) ;

Bi t mapDat a bmCopy = bCopy. LockBi t s( new Rect angl e( 0, 0,
bCopy. Wi dt h, bCopy. Hei ght ) , I mageLockMode. ReadWr i t e,

i nt st r i de2 = st r i de * 2;
Syst em. I nt Pt r Sr cScan0 = bmCopy. Scan0;

unsaf e
{

byt e * pSr c = ( byt e *) Sr cScan0;

i nt nWi dt h = cur I mage. Wi dt h - 2;
i nt nHei ght = cur I mage. Hei ght - 2;

i nt nPi xel ;

{
f or ( i nt x=0; x < nWi dt h; x++ )
{
nPi xel = ( ( ( ( pSr c[ 2] * conMat . el ement s[ 0, 0] ) +
( pSr c[ 5] * conMat . el ement s[ 0, 1] ) +

( pSr c[ 2 + st r i de] * conMat . el ement s[ 1, 0] ) +
( pSr c[ 2 + st r i de2] * conMat . el ement s[ 2, 0] ) +
( pSr c[ 8 + st r i de2] * conMat . el ement s[ 2, 2] ) )
/ conMat . Fact or ) + conMat . Of f set ) ;

i f ( nPi xel < 0) nPi xel = 0;
i f ( nPi xel > 255) nPi xel = 255;

p[ 5 + st r i de] = ( byt e) nPi xel ;

________________________________________________________________________
419
( pSr c[ 1 + st r i de2] * conMat . el ement s[ 2, 0] )
+
( pSr c[ 4 + st r i de2] * conMat . el ement s[ 2, 1] )
+






p += 3;
pSr c += 3;
}
p += nOf f set +6;
pSr c += nOf f set +6;
}
}

bCopy. Unl ockBi t s( bmCopy) ;


}

Hay que tener en mente que para cada matriz de convolucin se tendr un filtrado
diferente, es lo que veremos a continuacin.

8.2.3.1 Borrado Gaussiano (Blur)

Este filtro se obtiene al aplicar un kernel de 3 x3 como el siguiente:

Jenaro C. Paz
________________________________________________________________________
420
1 2 1
2 nWeight 2
1 2 1

Dividiendo entre un factor nWeight +12

gImage.GaussianBlur

publ i c st at i c Bi t map Gaussi anBl ur ( Bi t map cur I mage, i nt nWei ght / *
def aul t t o 4*/ )
{
ConvMat r i x conMat = new ConvMat r i x( ) ;
conMat . i ni t i al i ze ( 1) ;
conMat . el ement s[ 1, 1] = nWei ght ;
conMat . el ement s [ 0, 1] = conMat . el ement s[ 1, 0] =
conMat . el ement s[ 1, 2] = conMat . el ement s[ 2, 1] = 2;
conMat . Fact or = nWei ght + 12;

r et ur n gI mage. DoConvol ut i on3x3( cur I mage, conMat ) ;
}


upl oadI mage=gI mage. SkewVer ( upl oadI mage, 30) ;

utilizamos

upl oadI mage=gI mage. Gaussi anBl ur ( upl oadI mage, 8) ;

un borrado Gaussiano modificado la imagen original usando un peso de 8 en la matriz de
convolucin .

Figura 8.31. Gaussian Blur de imagen
________________________________________________________________________
421
8.2.3.2 Emboss (realzado)


2 0 0
0 -1 0
0 0 -1

gImage.Emboss

publ i c st at i c Bi t map Emboss( Bi t map cur I mage)
{
conMat . i ni t i al i ze( 0) ;
conMat . el ement s[ 0, 0] = 2;
conMat . el ement s[ 1, 1] = conMat . el ement s[ 2, 2] = - 1;

conMat . Of f set = 127;

}


upl oadI mage=gI mage. Gaussi anBl ur ( upl oadI mage, 8) ;

utilizamos

upl oadI mage=gI mage. Emboss( upl oadI mage) ;

para procesar una imagen a color, obtendremos una nueva imagen donde hemos realizado
un realzado modificado la imagen original.

Figura 8.32. Emboss de imagen
Jenaro C. Paz
________________________________________________________________________
422
8.2.3.3 Sharpen (nitidez)


0 -1 0
-1 nWeight -1
0 -1 0

Dividiendo entre un factor nWeight -4

gImage.Sharpen

publ i c st at i c Bi t map Shar pen( Bi t map cur I mage, i nt nWei ght {
conMat . el ement s[ 0, 1] = conMat . el ement s[ 1, 0] =
conMat . Fact or = nWei ght - 4;

}


upl oadI mage=gI mage. Emboss( upl oadI mage) ;

utilizamos

upl oadI mage=gI mage. Shar pen( upl oadI mage, 10) ;

una modificacin a la imagen original por nitidez.

Figura 8.33. Sharpen de imagen
________________________________________________________________________
423

8.2.3.4 Smooth (suavizado)

gImage.Smooth


1 1 1
1 nWeight 1
1 1 1

Dividiendo entre un factor nWeight +8

publ i c st at i c Bi t map Smoot h( Bi t map cur I mage, i nt nWei ght
{
conMat . el ement s [ 1, 1] = nWei ght ;
conMat . Fact or = nWei ght + 8;

}


upl oadI mage=gI mage. Shar pen( upl oadI mage, 10) ;

utilizamos

upl oadI mage=gI mage. Smoot h( upl oadI mage, 4) ;

una modificacin a la imagen original por suavizado.

Figura 8.34. Smooth de imagen

Jenaro C. Paz
________________________________________________________________________
424
8.2.3.5 Mean Renoval

gImage.MeanRemoval


-1 -1 -1
-1 nWeight -1
-1 -1 -1

Dividiendo entre un factor nWeight - 8

publ i c st at i c Bi t map MeanRemoval ( Bi t map cur I mage, i nt nWei ght / *
def aul t t o 9*/ )
{
conMat . i ni t i al i ze( - 1) ;
conMat . Fact or = nWei ght - 8;

}


upl oadI mage=gI mage. Smoot h( upl oadI mage, 4) ;

utilizamos

upl oadI mage=gI mage. MeanRemoval ( upl oadI mage, 4) ;

una modificacin a la imagen original por MeanRemoval.

Figura 8.35. Mean Removal de imagen
________________________________________________________________________
425
8.2.3.6 Edge Detection Quick

gImage.EdgeDetectionQuick


-1 -1 -1
0 0 0
1 1 1

publ i c st at i c Bi t map EdgeDet ect i onQui ck( Bi t map cur I mage)
{
conMat . el ement s[ 0, 2] = - 1;


}


upl oadI mage=gI mage. MeanRemoval ( upl oadI mage, 4) ;

utilizamos

upl oadI mage=gI mage. EdgeDet ect i onQui ck( upl oadI mage, 4) ;

una modificacin a la imagen original por deteccion de orillas.

Figura 8.36. Edge Detection de imagen
Jenaro C. Paz
________________________________________________________________________
426
8.2.3.7 Deteccion de orillas por Convolucin (Mtodo Sobel)


1 0 -1
2 0 -2
1 0 -1

Y luego otro kernel de 3 x3 como el siguiente:

1 2 1
0 0 0
-1 -2 -1

gImage.EdgeDetectionConvolution

publ i c st at i c Bi t map EdgeDet ect i onConvol ut i on( Bi t map cur I mage, shor t
nType, byt e nThr eshol d)
{


swi t ch ( nType)
{
case SOBEL_EDGE_DETECT:
br eak;
case PREWI TT_EDGE_DETECT:
br eak;
case KI RSH_EDGE_DETECT:
br eak;
}
________________________________________________________________________
427

gI mage. DoConvol ut i on3x3( cur I mage, conMat ) ;

swi t ch ( nType)
{
case SOBEL_EDGE_DETECT:
br eak;
case PREWI TT_EDGE_DETECT:
br eak;
case KI RSH_EDGE_DETECT:
br eak;
}

gI mage. DoConvol ut i on3x3( bTemp, conMat ) ;

/ / GDI + st i l l l i es t o us - t he r et ur n f or mat i s BGR, NOT RGB.
Bi t mapDat a bmDat a = cur I mage. LockBi t s( new Rect angl e( 0, 0,
Bi t mapDat a bmDat a2 = bTemp. LockBi t s( new Rect angl e( 0, 0,

i nt st r i de = bmDat a. St r i de;
Syst em. I nt Pt r Scan0 = bmDat a. Scan0;
Syst em. I nt Pt r Scan02 = bmDat a2. Scan0;

unsaf e
{
byt e * p2 = ( byt e *) ( voi d *) Scan02;

i nt nWi dt h = cur I mage. Wi dt h * 3;

i nt nPi xel = 0;

f or ( i nt y=0; y<cur I mage. Hei ght ; ++y)
{
Jenaro C. Paz
________________________________________________________________________
428
{
nPi xel = ( i nt ) Mat h. Sqr t ( ( p[ 0] *p[ 0] ) + ( p2[ 0] *
p2[ 0] ) ) ;
i f ( nPi xel <nThr eshol d) nPi xel = nThr eshol d;
i f ( nPi xel >255) nPi xel = 255;
p[ 0] = ( byt e) nPi xel ;
++p;
++p2;
}
p += nOf f set ;
p2 += nOf f set ;
}
}

cur I mage. Unl ockBi t s( bmDat a) ;
bTemp. Unl ockBi t s( bmDat a2) ;

}



utilizamos

upl oadI mage=gI mage. EdgeDet ect i onConvol ut i on( upl oadI mage,
SOBEL_EDGE_DETECT, 200) ;

una modificacin a la imagen original por deteccion de orillas Sobel.

Figura 8.37. Deteccin de orillas en imagen (Sobel)

8.2.3.8 Edge Detection por Convolucin (Mtodo Prewitt)

________________________________________________________________________
429

1 0 -1
1 0 -1
1 0 -1


1 1 1
0 0 0
-1 -1 -1



utilizamos

PREWI TT_EDGE_DETECT, 200) ;

una modificacin a la imagen original por deteccion de orillas Prewitt.

Figura 8.38. Deteccin de orillas en imagen (Prewitt)

8.2.3.9 Edge Detection por Convolucin (Mtodo Kirsh)


5 -3 -3
5 0 -3
5 -3 -3

Jenaro C. Paz
________________________________________________________________________
430

5 5 5
-3 0 -3
-3 -3 -3



utilizamos

KI RSH_EDGE_DETECT, 200) ;

una modificacin a la imagen original por deteccion de orillas Prewitt.

Figura 8.39. Deteccion de orillas en imagen (Kirsh)

Edge Detection

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Edge Detection

Cargado por

Copyright:

Formatos disponibles

Textos Universitarios / Serie Docencia

También podría gustarte