// ********************************************************************

// Processamento de Imagens - ELE0005 ************************************

// PPGEE - DELET - UFRGS ************************************************

// Anderson da Silva Alves - 00204269 **************************************

// Detecção da Face para acessos restritos************ *******************

// ********************************************************************

// ************************INÍCIO******************************************

//---------------------------------------------------------------------------

#include <vcl.h>

#pragma hdrstop

#include "TFrmMain.h"

#include <lili2.h>

#include <borland.h>

//---------------------------------------------------------------------------

#pragma package(smart_init)

#pragma resource "*.dfm"

TfrmMain *frmMain;

//declaraçao dos mapas a serem usados

LRgbMap myMap;

LGrayMap765 GrayMap1,GrayMap2;

//---------------------------------------------------------------------------

__fastcall TfrmMain::TfrmMain(TComponent* Owner)

 : TForm(Owner)

//---------------------------------------------------------------------------

void __fastcall TfrmMain::Button3Click(TObject *Sender)

//Procedimento para abrir imagem e mostrar no form

if (OpenPictureDialog1->Execute())

myMap.ReadBMP(OpenPictureDialog1->FileName.c_str());

LBUtil::RgbMapToTBitmap(&myMap,Image1->Picture ->Bitmap);

//Habilita o botão de conversão para tons de cinza

Button1->Enabled = true;

Image1->Refresh();

//---------------------------------------------------------------------------

void __fastcall TfrmMain::Button1Click(TObject *Sender)

//Mapa em tons de cinza

GrayMap1 = myMap;

//Mostrar a imagem em tons de cinza no form

LBUtil::GrayMap765ToTBitmap(&GrayMap1,Image2->Picture->Bitmap);

Button2->Enabled = true;

//---------------------------------------------------------------------------

void __fastcall TfrmMain::Button2Click(TObject *Sender)

GrayMap2 = GrayMap1;

//armazena em uma variavel o valor do limiar definido pelo usuario

int limiar = StrToInt(Edit1->Text);

//laço para a construçao da imagem binarizada

for (int lin=0;lin<GrayMap2.GetRowCount(); lin++)

for (int col=0;col<GrayMap2.GetColCount(); col++)

if (GrayMap2.Value(lin,col).Value < limiar)

GrayMap2.Value(lin,col).Value = 0;

else GrayMap2.Value(lin,col).Value=765;

//Método para mostrar a imagem em tons de cinza no form

LBUtil::GrayMap765ToTBitmap(&GrayMap2,Image3->Picture->Bitmap);

Image3->Refresh();

//---------------------------------------------------------------------------
// **************************FIM******************************************

#pragma hdrstop

#include <condefs.h>

#pragma argsused

#include <stdio.h>

#include <complex.h>

#include <math.h>

#include <alloc.h>

#include <iostream.h>

#include "lili2.h"

using namespace std;

// Definições.

#define pi 3.1415

// Declaração de processos.

limage* lconverte_grayscale( limage* imagem1 );

limage* ldiferenca (limage* imagem1, limage* imagem2);

void gerador_de_histograma (limage* imagem1);

limage* lalargamento_de_histograma(limage* imagem1);

limage* lbinariza(limage* imagem1,int th1);

limage* lfiltro_erosao( limage* imagem1 );

limage* lfiltro_dilatacao( limage* imagem1 );

limage* llocaliza( limage* imagem1 );

// Programa Principal.

int main( int argc, char** argv )

// Declaração dos ponteiros das imagens.

limage* src1 ;

limage* src2 ;

limage* dst1 ;

limage* dst2 ;

limage* dst ;

limage* final;

int th;

// **************************************************************************

//COMPOSTO DE 4 ETAPAS:

//- PRE-PROCESSAMENTO: 1. Minimizar falhas e 2. Detectar bordas (método da convolação );

//- SEGMENTAÇÃO;

//- EXTRAÇÃO DE CARACTERISTICAS; E

//- CLASSIFICAÇÃO.

// **************************************************************************
// **************************************************************************

// Conversão da imagem fonte de RGB para Grayscale. *************************

// **************************************************************************

limage* lconverte_grayscale( limage* imagem1 )

larray A1_r, A1_g, A1_b, A2;

limage* imagem2;

imagem2 = limage_new( limage_get_width(imagem1), limage_get_height(imagem1),

LIMAGE_TYPE_GRAYSCALE ) ;

A1_r=limage_as_array(imagem1,LCHANNEL_GRAY);

A1_b=limage_as_array(imagem1,LCHANNEL_GRAY);

A1_g=limage_as_array(imagem1,LCHANNEL_GRAY);

A2=limage_as_array(imagem2,LCHANNEL_DEFAULT);

int i, j;

int tmp;

for( i=0 ; i < limage_get_height(imagem1) ; i++ )

for( j=0 ; j < limage_get_width(imagem1) ; j++ )

{
 tmp = A1_r[i][j] ;

tmp += A1_g[i][j] ;

tmp += A1_b[i][j] ;

tmp /= 3 ;

A2[i][j] = (lpixel)tmp ;

//printf( "%02x.%02x.%02x ", r[i][j], g[i][j], b[i][j] ) ;

//printf( "\n" ) ;

printf ("Conversão...Processada. \n");

return imagem2;

// **************************************************************************

// Binarização. *************************************************************

// **************************************************************************

limage* lbinariza(limage* imagem1,int th1)

larray A1,A2;

limage* imagem2;

imagem2 = limage_clone(imagem1);

A1=limage_as_array(imagem1,LCHANNEL_GRAY);

A2=limage_as_array(imagem2,LCHANNEL_GRAY);
 int cmax;

int i,j,

lmax= limage_get_width (imagem1) ;

cmax= limage_get_height(imagem1) ;

for (i=1;i<cmax-1;i++)

for(j=1;j<lmax-1;j++)

if ( A1[i][j] > th1)

A2[i][j]=255;

if ( A1[i][j] < th1)

A2[i][j]=0;

printf("Binarização...Processado\n");

return imagem2;

// **************************************************************************

// Aplicando Sobel ********************************************************

// **************************************************************************
 e[j-2][i-2] = (4*(x[j][i])-(x[j-1][i] + x[j][i-1] + x[j][i+1] + x[j+1][i]));

if(r[j-2][i-2] > min){ // limiar para realçar bem as bordas da imagem

r[j-2][i-2] = 255;

if(r[j-2][i-2]< min){

f[j-2][i-2] = 0;

if(r[j-2][i-2]>= min && e[j-2][i-2]>=0){

f[j-2][i-2] = 255;

if(r[j-2][i-2]>= min && e[j-2][i-2]<0){// e nao resulta em negativo, pois a imagem é

binarizada

f[j-2][i-2] = 25;

y[j-2][i-2] = (lpixel) f[j-2][i-2];

};
// **************************************************************************

// Filtro de Erosão. ********************************************************

// **************************************************************************

// **************************************************************************

//************************* Transformada de Hough ******************************

// **************************************************************************

printf("\n\nAplicando a transformada de Hough...");

maxrho = floor((float)sqrt(pow(N,2) + pow(N,2))); // maior rho possivel (diagonal)

outacc = limage_new(180, 2*maxrho, LIMAGE_TYPE_GRAYSCALE);

acc = limage_as_array(outacc, LCHANNEL_DEFAULT);

for(i = 0; i < 2*maxrho; i++)

for(j = 0; j < 180; j++) acc[i][j] = 0; // inicializa o acumulador

accmax = 0;

for(i = 0; i < cont; i++)

k = 0;

theta = -pi/2;
 for(j = 0; j < 180; j++)

rho = floor(x[i]*cos(theta) + y[i]*sin(theta)); // calcula a distancia rho da origem

aux = rho + maxrho;

acc[aux][k] = acc[aux][k] + 1; // atualiza o acumulador

if(i == 0) theta_vec[j] = theta*180/pi; // monta um vetor com os angulos de varredura

em graus

k++;

theta += pi/180;

if(acc[aux][k] > accmax)

accmax = acc[aux][k]; // valor maximo do acumulador

ir = aux; // linha do valor máximo

it = k; // coluna do valor máximo

rho_vec[i] = i-maxrho; // monta um vetor com os possiveis valores de rho

ang = theta_vec[it]; // angulo com o eixo das abcissas

dist = rho_vec[ir]; // distancia da origem

printf(" rho=%d, theta=%.1f", rho, theta);

//********************** ****************************************************