Archive

Archive for the ‘Visao Computacional’ Category

Audio spectrum Analyzer

fevereiro 7, 2013 5 comentários

Oi Pessoal !

Minha história com o Analisador de Espectro de Frequências é bem antiga, tudo começou em meados da década de 90 eu era praticamente uma criança,  me lembro claramente que nesta época um player de áudio dominava os computadores com windows 95 o clássico winamp, pois bem eu me deliciava acompanhando  as músicas junto com as “barras” que se moviam conforme a música evoluía, associava cada batida , cada voz, cada timbre, com o então na época chamado por mim “barras do winamp’  e em minha mente tentava entender como  aquelas “Barras” pareciam literalmente dançar com a música. A curiosidade aumentou quando meu pai comprou um micro system da aiwa ele tinha uma grande tela frontal com um analizador de espectro, o tempo foi passando e fui entendendo como um analisador de espectro de frequência funciona !

Na realidade tudo é bem simples, o que “eles” fazem é separar as bandas das frequências discretas retornadas pela transformada de Fourier, lembrando que a faixa de frequência possível para análise sempre dependerá da taxa de amostragem do sinal de áudio, claro estes visualizadores de espectros (Aiwa, Sony, winamp, etc) possuem apenas um caráter estético e muitos deles não mostram na realidade as frequências precisas e onde realmente elas estão acontecendo!

A faixa de frequência audível de um ser humano é de 20hz até 20Khz, então para construir um analisador de espectro que atenda as características audíveis do ser humano teremos que ter um sinal de áudio com uma taxa de amostragem igual ou superior 44100hz, seguindo o Teorema de Nyquist “A frequência de amostragem de um sinal analógico, para que possa posteriormente ser reconstituído com o mínimo de perda de informação, deve ser igual ou maior a duas vezes a maior frequência do espectro desse sinal“, então sé temos uma frequência de amostragem de 44100 e dividir por 2 -> 44100/2 = 22050, opa este valor atende a maior frequência audível do ser humano, lembre, se você trabalhar com taxa de amostragem menor poderá estar perdendo informações(Análise) de frequências que  estão em nosso campo audível, pronto já sabemos qual é a maior frequência que nosso analisador de espectro  é capaz de alcançar  é de 22050hz, agora precisamos decidir qual será a ordem de resolução da  frequência, quanto menor a ordem mais apurado seu analisador será, porém exige muito mais processamento ao computar a transformada de fourier, estou utilizando 4096 pontos isto me dá uma resolução de ordem = 10,7666015625, isto quer dizer que podemos estar perdendo em algum ponto a precisão das frequências capturadas na ordem perto de 11hertz, o que considero bem aceitável para o que precisamos aqui, ao computar a Transformada Fourier precisamos calcular a raiz quadrada da soma do quadrado dos seus componentes reais e imaginários e isso nós dá a magnitude do coeficiente de FFT para cada frequência.  OK com isso agora sabemos que nossa menor frequência possível de ser capturada será de  44100/ 4096 = 10,7666015625hz e a nossa maior frequência possível de ser capturada será de  22050hz. Legal lembre-se que ao computar a transfonada de fourier utilizando 4096 pontos teremos que sempre remover a segunda metade dos resultados pois é apenas um espelho dos resultados da primeira metade, então como resultado teremos 4096 /2 = 2048 frequências discretas retornadas, com isto você saberá quais serão todas as suas 2048 bandas de frequências:

1 -> 10,7666015625000

2 -> 21,5332031250000

3 -> 32,2998046875000

4 -> 43,0664062500000

5 -> 53,8330078125000

2047 -> 22039,2333984375

2048 – > 22050

Reparem que entre a mínima e a máxima ainda estamos dentro da faixa audível humana !

O retorno destes 2048 pontos já é o seu espectro de frequência, você ainda pode converter os resultados em escala logarítmica  ou manter na escala linear, vai depender de sua necessidade ou seja se a amplitude do sinal precisa estar definida em decibéis ou não,  fiz um protótipo em python, na realidade o protótipo funciona como um player de arquivos .wav com canais em  mono, o protótipo funciona apresentando o Espectro de Frequência em real time  enquanto um áudio é executado,  veja o teste da escala audível humana !

Legal Funciona direitinho 🙂

Veja ele funcionando com uma música sendo tocada !

É bastante interessante analisar e ver como certas notas produzem harmônicos que ressoam em diferentes frequências que na realidade define a característica do timbre !

Até a próxima !

Eder

Making My Own Smile Detector Part 1

abril 16, 2011 4 comentários

Olá

Estive lendo algumas literaduras sobre expressões faciais aplicado a robótica, sempre fui um tanto curioso em saber e entender como sistemas robóticos conseguem definir comportamentos e classificar expressões humanas …

Pois bem o caminho não é tão complicado quanto esperava em 1 final de semana chuvoso me veio a inspiração para iniciar um detector de sorrisos a pricipio por amostra de fotos com pessoas para adquirir os conceitos obtidos na não tao vasta literatura sobre classificação robótica facial.

A principio me veio em mente a renomada patente da SONY “smile shutter”, como era de se esperar não encontrei documentação descrevendo os métodos utilizados pela SONY.

Então resolvi seguir sozinho tinha em mente que para conseguir identificar sorrisos iria precisar aplicar algumas métricas geométricas e biometria para definir tal expressão.

Traçando alguns pontos principais para o sucesso:

* Identificar faces
* Identificar boca
* Identificar olhos
* Identificar as extremidades dos olhos e boca
* Definir ponto de Origem e aplicar escala invariante para compensar diferentes tamanhos de imágens
* Calcular distancia da boca (lábio superior, lábio inferior, extremidade do lado esquerdo e direito)

Alguns destes pontos são fáceis de se aplicar …

Iniciei pela identificação da face, logo após parti para a regiao da boca seguido dos olhos na qual me parece ser um ponto fundamental para a identificação do sorriso pois com ele se consegue fazer cálculos biométricos.

Pois bem agora faltava encontrar as extremidades da região da boca e dos olhos, dois pontos X,Y para a região dos olhos e quatro pontos para a região da boca antes destes passos segmentei as regiões da boca e olhos para ter melhor performace ao percorrer a matriz da imágem na procura dos pontos de interesse. Testei rapidamente SOBEL e tive resultados não satisfatórios fui então para CANNY e o resultado foi esplêndido para encontrar as extremidades das regioes segmentadas, um ajuste fino com filtro deve ser pensado para melhorar o resultado da região dos olhos.

Segue tela de dois testes :

Na Imagem podemos notar que a região da boca e dos olhos não tiveram bons resultados (rostos estão levemente inclinados). Para Debug estou mostrando 5 fotos de saida, sao elas, região da boca, olhos, regiao dos olhos aplicado com filtro, imagem com os pontos da regiao da boca e imagem com a face boca e olhos..

Vamos a outro teste:

Bom podemos notar que o resultado foi melhor para este rosto o angulo frontal caiu como uma luva na regiao segmentada da boca todos os pontos estão exatamente sobre suas extremidades, ainda estou tendo dificuldades para a região dos olhos acredito que possa melhorar dilatando a imágem …

Para o proximo post espero mostrar os avanços e concluir os pontos restantes que são:
* Definir ponto de Origem e aplicar escala invariante para compensar diferentes tamanhos de imágens
* Calcular distancia da boca (lábio superior, lábio inferior, extremidade do lado esquerdo e direito)

Até

Eng Eder de Souza

Find Circular Objects in images

Olá pessoal !

Bom vamos falar hoje sobre como identificar objetos dentro de imagens ..

Fiz alguns testes para identificar objetos circulares pelo método “covariance matrix” existem outros métodos por exemplo a transformada de  Hough pode ser modificado para identificar circulos!

Mas vamos aos testes

vamos iniciar por uma imagem geometrica mais simples como esta

A idéia é encontrar todos os objetos da figura para depois comparar suas propriedades !

Para isso vamos tentar encontrar todos os objetos conectados dentro de uma figura utilizado Label …

Apos isso teremos que percorrer todos os objetos e aplicar a formula  covariance matrix !

Se todas as propriedades forem verdadeiras teremos um circulo na imagem …

Segue código que faz tudo isso:

#Eng Eder de Souza Find Circular Objects Example Source
from __future__ import division
from scipy.misc.pilutil import imread
from scipy import ndimage
from pymorph import add4dilate, binary, blob
from numpy import *
import pylab
import math

f = imread(‘hgjkdngm.GIF’, flatten=True)
f = binary(f, k=110)
arr=asarray(f)
l, n = ndimage.label(arr)
ObjectsAreas = blob(l, ‘area’, output=’data’)
ObjectsAreas = asarray(ObjectsAreas)
ObjectsBoundingbox = blob(l,’boundingbox’, output=’data’)
NumberOfCircles = 0
fo = ndimage.find_objects(l)

for i in range(n):

# Squares or Retangular Objects
(x1, y1, x2, y2) = ObjectsBoundingbox[i]
RegionArea = (x1 – x2) * (y1 – y2)
Area = ObjectsAreas[i]

x = array(where(arr[fo[i]] == 1))
# compute mean
m = x.mean(axis=1)
# compute covariance matrix
# http://en.wikipedia.org/wiki/Estimation_of_covariance_matrices
Sxx = (1.0/n)*sum((x[0]-m[0])*(x[0]-m[0]))
Sxy = (1.0/n)*sum((x[0]-m[0])*(x[1]-m[1]))
Syy = (1.0/n)*sum((x[1]-m[1])*(x[1]-m[1]))
if Syy > Sxx:

div = float(Syy/Sxx)
result = (div -1) * 100

else:

div = float(Sxx/Syy)
result = (div -1) * 100

#test conditions for objects circules!
if RegionArea != Area and Sxy < 5 and result < 100:

NumberOfCircles += 1

print NumberOfCircles

Esteganografia Spectrograma em Arquivos de Audio

junho 29, 2010 5 comentários

Vamos falar hoje sobre um assunto bem bacana e antigo, mas que nos dias atuais pode ser utilizado de varias formas para esconder informaçoes, ja faz um bom tempo que escrevi alguns sources que demonstra como converter uma imagen para sinais de audio digital para depois recuperar esta informaçao pelo Spectrograma do sinal de audio injetado, hoje em dia com toda a revoluçao VOIP poderiamos certamente passar varios tipos de informaçoes codificadas dentro de arquivos de voz !!!

Bom vamos as explicaçoes minha ideia seria  percorrer toda a imagen em busca dos valores RGB e montar uma matriz correspondente, com isso poderia usar a transformada de fourrier no modo inverso 🙂 Pronto assim temos um sinal, com o sinal em maos eu injeto esses dados em um arquivo de audio e assim criamos um arquivo com um som bem particular, a proxima etapa seria recuperar estes dados,  conseguimos isso pegando o spectrograma do arquivo de audio gerado …

Bom vamos as demonstraçoes!

Vamos pegar um arquivo .bmp  monocromatico para testar, de inicio vamos pegar este como exemplo.

detect:~# python imageWAV.py eder.bmp
Arquivo de audio gerado
detect:~#

com isso temos um arquivo wav da imagem  !!
Escute aqui o Arquivo Gerado.
saida_spectro.wav

Haha temos um sinal de audio convertido a partir de uma imagem lol

Mas e ae vamos recuperar a imagem pelo spectro do arquivo de audio

detect:~# python son4.py

E ae esta o resultado do spectro do audio !!!

Legal 🙂

Por falta de tempo eu nao fiz mais testes !

[]’s

Eng Eder de Souza

Principios para identificação de caracteres em Python

fevereiro 8, 2010 4 comentários

Olá Galera,

No meu último post descobri como é agradável brincar com manipulação de imagens em Python (PIL),  então começei a imaginar como aplicar isso em algo para melhor ser aproveitado, no mesmo momento me veio a cabeça  “pq não identificar caracteres ??”

Mas nada na vida é tão simples como pensamos ser, a principio me perguntei “como pegar letras de uma palavra separadamente?” muitas perguntas  hahaha então descobri que antes de iniciar qualquer método teria antes que separar as letras de uma palavra para só assim avançar …

A idéia Seria uma palavra sem firulas em uma font black e em um fundo branco, assim poderia abrir esta imagem procurar pela ocorrencia da cor mais escura e quando a encontrasse eu estaria em uma letra da palavra assim eu poderia pegar a localização para depois iniciar a parte mais avançada do script segue o source que faz a brincadeira …

Imagem Original para os meus testes:

Então Aplicando na prática temos:

Compartilhando o source:

#Eder de Souza
#Encontrar Letras

from PIL import Image
import ImageFont, ImageDraw, ImageOps

im2 = Image.open(“eder.jpg”)

letraini = False
achouletra=False
inicio = 0
fim = 0
letras = []
for y in range(im2.size[0]): 
  for x in range(im2.size[1]): 
    pixel = im2.getpixel((y,x))
    r,g,b = pixel
    color = (r + g + b) / 3
    if color < 90:
      letraini = True
  if achouletra == False and letraini == True:
    achouletra = True
    inicio = y
  if achouletra == True and letraini == False:
    achouletra = False
    fim = y
    letras.append((inicio,fim))

  letraini=False

draw = ImageDraw.Draw(im2)

for y in (letras):
    inicio,fim = y
    draw.rectangle((inicio, 0, fim, (im2.size[1]-1)), outline=(16, 152, 22))
im2.save(“output.jpg”)
print “verifique arquivo de saida”

Logo Postareis mais testes quando tiver tempo

Att,

Eng Eder de Souza

Computação Gráfica Python em ação

fevereiro 4, 2010 3 comentários

Estava eu deitado sem nada para fazer !!

A parte mais complicada foi alinhar os pixels na tela.

Funciona da seguinte maneira abrimos uma imagem capturando cada pixel dela para depois converter em ascii, o RGB de retorno é substituido por um caractere após a média…

Resultado da brincadeira !!

Imagem Original

Convertendo para Ascii

##############################################################

Imagem Original

Convertendo para ascii

Source para quem gosta de brincar:

###Eng Eder de souza
##03/02/2010
from PIL import Image
import sys

arquivo=sys.argv[1]

img = Image.open(arquivo)

if img.size[0] > 80:
   img.thumbnail((89,89))

cont = 1

for row in range(img.size[1]):

    for col in range(img.size[0]):
        pixel = img.getpixel((col,row))
        if type(pixel) == int:
           r = pixel
           g = pixel
           b = pixel
        else:
           r,g,b = pixel
        color = (r + g + b) / 3

        if cont < img.size[0]:

     if color < 19:
               print(‘&’),
          elif color < 50:
               print(‘8’),
          elif color < 75:
               print(‘0’),
          elif color < 100:
               print(‘$’),
          elif color < 130:
               print(‘2’),
          elif color < 165:
               print(‘1’),
          elif color < 180:
               print(‘|’),
          elif color < 200:
               print(‘;’),
          elif color < 218:
               print(‘:’),
          elif color < 229:
               print(“‘”),
          elif color <= 255:
               print(‘ ‘),
                cont = cont + 1
        else:
     if color < 19:
                        print(‘&’),
                elif color < 50:
                        print(‘8’),
                elif color < 75:
                        print(‘0’),
                elif color < 100:
                        print(‘$’),
                elif color < 130:
                        print(‘2’),
                elif color < 165:
                        print(‘1’),
                elif color < 180:
                        print(‘|’),
                elif color < 200:
                        print(‘;’),
                elif color < 218:
                        print(‘:’),
                elif color < 229:
                        print(“‘”),
                elif color <= 255:
                        print(‘ ‘),
                print
                cont = 1

Até

Portabilidade + DBO + Descobrir Operadoras

novembro 26, 2009 7 comentários

Olá Povo !!

Já faz um bom tempo que tento rotear chamadas de acordo com a operadora na qual o número discado pertence, as rotas ficaram uma bagunça com a chegada da portabilidade, como não tenho dinheiro para pagar um DBO tentei improvisar.

O Script feito em Python ainda falha algumas vezes, mas já é um começo o correto seria treinar o banco de dados do gocr para capturar o captcha com mais precisão mas nao estou tendo tempo de brincar com isso…

# -*- coding: iso-8859-1 -*-

#Eder de Souza 23/11/2009

import re
import ClientCookie
import commands
import sys
import os
import re
inc = 0
MaxTentativas = 15

tel=sys.argv[1]
while inc < MaxTentativas:
  inc = inc + 1
  cj = ClientCookie.MozillaCookieJar()
  opener = ClientCookie.build_opener(ClientCookie.HTTPCookieProcessor(cj))
  ClientCookie.install_opener(opener)
  r = ClientCookie.urlopen(“http://consultanumero.abr.net.br:8080/consultanumero/jCaptcha.do?metodo=carregar“)
  fp = open(‘Captcha.jpg’,’w’)
  fp.write(r.read())
  fp.close()
  cj.save(“infer”, ignore_discard=True, ignore_expires=True)
  commands.getoutput(‘convert Captcha.jpg Captcha.png’)
  commands.getoutput(‘pngtopnm Captcha.png > Captcha.pnm’)
  commands.getoutput(‘ppmchange -remainder black -closeness 20 rgbi:.91/.8/.58 white rgbi:.8/.8/.91 white rgbi:.69/.91/.91 white Captcha.pnm > Captcha_End.pnm’)
  captcha = commands.getoutput(‘gocr -C a-zA-Z0-9 -m 2 -a 90 -d 2 Captcha_End.pnm’)
  rmspace = captcha.replace(‘ ‘, ”)
  rmreturn = rmspace.replace(‘\n’, ”)
  rmunderline  = rmreturn.replace(‘_’,”)
  res = re.search(‘([a-zA-Z0-9]+)’, rmunderline)
  result = res.group(1)
  cj = ClientCookie.MozillaCookieJar()
  cj.load(“infer”, ignore_discard=True, ignore_expires=True)
  opener = ClientCookie.build_opener(ClientCookie.HTTPCookieProcessor(cj))
  ClientCookie.install_opener(opener)
  pagina = opener.open(‘http://consultanumero.abr.net.br:8080/consultanumero/consultarTnSemLogin.do?tn=’+tel+’&captcha=’+result+’&metodo=consultar&#8217;).read()
  if “Nome da prestadora” in pagina:

    pagina  = pagina.replace(‘<br>’,”)
    find = re.search(‘Nome da prestadora: (.*)’, pagina)
    operadora = find.group(1)
    print operadora
    sys.exit()

segue uma tela dele funcionando:

Até mais

Eder

Protótipo: Asterisk + Visão Computacional = Monitoramento

/*

#    _
#   |_)\_/
#   |_) |
#
#
#    ___    _              _       ___
#   | __|__| |___ _ _   __| |___  / __| ___ _  _ _____ _
#   | _|/ _` / -_) ‘_| / _` / -_) \__ \/ _ \ || |_ / _` |
#   |___\__,_\___|_|   \__,_\___| |___/\___/\_,_/__\__,_|
Conecta Uma Web Cam e fica a espera de qualquer movimento detectado e faz
conexão com o Asterisk para iniciar Ligação …
Instruções de Compilação:
    DevC++: Tools > Compiler Options > Add linker -lhighgui -lcv -lcxcore
-lcvaux -lcvcam -lws2_32.
   
    Inserir todos os Includes do OpenCV e integrar ao compilador
   
————————————————————————————————————
Dependências:
    windows -> winsock2.h, WSDATA wsa_data, OpenCV.
    unix/linux -> <sys/types.h>, <sys/socket.h>, <arpa/inet.h>, OpenCV.
    comuns -> <iostream>, <unistd.h>, <string.h>, OpenCv
   
   
    Eng. Eder de Souza
    email: ederwan…@gmail.com, ederwan…@yahoo.com.br
   
     Data: 17-07-2009
    Visão Computacional + Asterisk para monitoramento via Web Cam
    Monitoramento de áreas sem presença de movimentos, se alguma percepção de
movimento for encontrado Servidor Asterisk Liga para comunicação …
   
*/
#include <stdlib.h>
 
// OpenCV includes.
#include <cv.h>
#include <highgui.h>
//
#include <iostream>
#include <process.h>
#include <time.h>
#include <unistd.h>
#include <string.h>
#ifdef unix
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#else
#include <winsock2.h>
#include <windows.h>
#include <winsock2.h>
#include <stdio.h>
WSADATA wsa_data;
#endif
 
#define DEFAULT_BUFLEN 512
//IP e Porta para se Conectar ao Socket Perl Asterisk
#define DEFAULT_PORT 8888
#define IP “192.168.0.34”
//Intervalo para Iniciar a Ligação entre um movimento detectado
//Valor em mili-Segundos
#define intervalo 50000
using namespace std;
long int cont = 0;
int Me_Liga() {
    //———————-
    // Declarando e inicializando Variaveis.
    int iResult;
    WSADATA wsaData;
    SOCKET ConnectSocket;
    struct sockaddr_in clientService;
    int recvbuflen = DEFAULT_BUFLEN;
    char *sendbuf = “Movimento Detectado\n”;
    char recvbuf[DEFAULT_BUFLEN] = “”;
    //———————-
    // Inicializando o  Winsock
    iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
    if (iResult != NO_ERROR) {
        printf(“WSAStartup Falhou com erro: %d\n”, iResult);
        return 1;
    }
    //———————-
    // Criando o Socket para se conectar ao Servidor
    ConnectSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (ConnectSocket == INVALID_SOCKET) {
        printf(“socket Falhou com erro: %ld\n”, WSAGetLastError());
        WSACleanup();
        return 1;
    }
    //———————-
    // IP e porta do Servidor Perl Asterisk para se conectar.
    clientService.sin_family = AF_INET;
    clientService.sin_addr.s_addr = inet_addr( IP );
    clientService.sin_port = htons( DEFAULT_PORT );
    //———————-
    // Conecta ao server em perl com o Asterisk.
    iResult = connect( ConnectSocket, (SOCKADDR*) &clientService,
sizeof(clientService) );
    if (iResult == SOCKET_ERROR) {
        printf( “Conexao Falhou com erro: %d\n”, WSAGetLastError() );
        closesocket(ConnectSocket);
        WSACleanup();
        return 1;
  }
    //———————-
    // Enviando mensagem para Servidor
    iResult = send( ConnectSocket, sendbuf, (int)strlen(sendbuf), 0 );
    if (iResult == SOCKET_ERROR) {
        printf(“send() Falhou com erro: %d\n”, WSAGetLastError());
        closesocket(ConnectSocket);
        WSACleanup();
        return 1;
    }
    printf(“Bytes envido: %d\n”, iResult);
    // Mata a Conexao com o Socket
    iResult = shutdown(ConnectSocket, SD_SEND);
    if (iResult == SOCKET_ERROR) {
        printf(“shutdown falhou com  erro: %d\n”, WSAGetLastError());
        closesocket(ConnectSocket);
        WSACleanup();
        return 1;
    }
    // Resposta do socket
    do {
        iResult = recv(ConnectSocket, recvbuf, recvbuflen, 0);
        if ( iResult > 0 )
            printf(“Bytes recebido: %d\n”, iResult);
        else if ( iResult == 0 )
            printf(“Conexao Encerrada\n”);
        else
            printf(“recebimento falhou com erro: %d\n”, WSAGetLastError());
    } while( iResult > 0 );

    // limpando
    closesocket(ConnectSocket);
    WSACleanup();
 
}

static void Thread1 (LPVOID lpParam){
   
   
  
            cont=cont+1;
            Sleep(intervalo);
   
    printf(“%d Contador \n”, cont);
  
  if(cont >= 1){
    cont=0;
    Me_Liga();
   
}
}

int main()
{
 //Cria uma janela
 cvNamedWindow(“Eng_Eder_souza”, CV_WINDOW_AUTOSIZE);
 
 //Cria objeto para captura.
 CvCapture* inputMovie;
 
 //Informa o modo de captura.
     inputMovie = cvCaptureFromCAM(0);

 
 //tamanho da imagem
 CvSize imgSize;
 imgSize.width = 320;
 imgSize.height = 240;
 
 //Imagens para usar no programa
 IplImage* greyImage = cvCreateImage( imgSize, IPL_DEPTH_8U, 1);
 IplImage* colourImage;
 IplImage* movingAverage = cvCreateImage( imgSize, IPL_DEPTH_32F, 3);
 IplImage* difference;
 IplImage* temp;
 IplImage* motionHistory = cvCreateImage( imgSize, IPL_DEPTH_8U, 3);
 
 //Retangulo nos objetos
 CvRect bndRect = cvRect(0,0,0,0);
 
 //Pontos para o retangulo
 CvPoint pt1, pt2;
 
 //Cria uma font para o objeto.
 CvFont font;
 
 
 
 int inicio = 0;
 
 //Buffer
 
 char Scores[60000];
 
          
 //centraliza X do retangulo
 int avgX = 0;
 
 //Indica a primeira vez do loop de um frame
 bool first = true;
 
 
 //Mantem proceços do Frame de pé
 for(;;)
 {
  //Pega o Frame da entrada de Video
  colourImage = cvQueryFrame(inputMovie);
 
  //Se nao existir mais framas cair fora do For
  if( !colourImage )
  {
   break;
  }
  
  //Primeira vez para iniciar Imagem
  if(first)
  {
   difference = cvCloneImage(colourImage);
   temp = cvCloneImage(colourImage);
   cvConvertScale(colourImage, movingAverage, 1.0, 0.0);
   
   first = false;
  }
  //else, faz a detecção de movimento
  else
  {
   cvRunningAvg(colourImage, movingAverage, 0.020, NULL);
  }
 
  //Converte a scala do video
  cvConvertScale(movingAverage, temp, 1.0, 0.0);
 
  //analiza o frame corrente
  cvAbsDiff(colourImage,temp,difference);
  
  //converte a imagem para grayscale.
  cvCvtColor(difference, greyImage, CV_RGB2GRAY);
  
  //Converte a imagem para black and white.
  cvThreshold(greyImage, greyImage, 70, 255, CV_THRESH_BINARY);
  
  cvDilate(greyImage, greyImage, 0, 18);
  cvErode(greyImage, greyImage, 0, 10);
 
  //acha o contador de imagens em video
  CvMemStorage* storage = cvCreateMemStorage(0);
        CvSeq* contour = 0;
  cvFindContours( greyImage, storage, &contour, sizeof(CvContour),
CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE );
 
  //processa cada movimento no frame corrente
        for( ; contour != 0; contour = contour->h_next )
        {
   //pega quadrado nos objetos em movimento
   bndRect = cvBoundingRect(contour, 0);
 
   pt1.x = bndRect.x;
   pt1.y = bndRect.y;
   pt2.x = bndRect.x + bndRect.width;
   pt2.y = bndRect.y + bndRect.height;
         sprintf(Scores, “Com Movimento”);
   
   
   if(inicio == 0){
            Me_Liga();
            inicio = 1;
            }
            else{
                
               
                 if(cont == 0){
                  //Inicia a Thread para o Intervalo de tempo para Ligar
                 _beginthread( Thread1, 0, NULL );}
                 }
   
            }
         
   
 
  //desenha um retangulo nos objetos em movimento.
  cvRectangle(colourImage, pt1, pt2, CV_RGB(255,0,0), 1);
 
        cvInitFont(&font, CV_FONT_HERSHEY_SIMPLEX, 0.8, 0.8, 0, 2);
  cvPutText(colourImage, Scores, cvPoint(60, 200), &font, cvScalar(0, 0, 300));
  
  //Mostra o Frame.
  cvShowImage(“Eng_Eder_souza”, colourImage);
  
  
  cvWaitKey(10);
  sprintf(Scores, “Sem Movimento”);
        printf(“Apenas um Frame\n”);
  //Escreve o Frame no video de saida
 
 }
 
 // Termina com a imagem o video e a janela
 cvReleaseImage(&temp);
 cvReleaseImage(&difference);
 cvReleaseImage(&greyImage);
 cvReleaseImage(&movingAverage);
 cvDestroyWindow(“Eng_Eder_souza”);
 
 cvReleaseCapture(&inputMovie);
 
 return(0);
}
 
 
///#####FIM#####
 
Agora Segue script em Perl que recebe o socket e dispara a Ligação via Asterisk
este deve estar no servidor Asterisk executando no servidor Asterisk.
 
exemplo “perl serverasteriskEder.pl 8888″
 
#Eng. Eder de Souza
#    email: ederwan…@gmail.com, ederwan…@yahoo.com.br
#    Data: 22-09-2008
use IO::Socket::INET;
use strict;

my $numero;
my $arquivo;
my $r;
my $port = shift
    or die”Falta o numero da porta\n”;
my $socket = IO::Socket::INET->new(‘LocalPort’ => $port,
                                   ‘Proto’ => ‘tcp’,
                                   ‘Listen’ => SOMAXCONN)
    or die “Can’t create socket ($!)\n”;
print “Server listening\n”;
while (my $client = $socket->accept) {
    my $name = gethostbyaddr($client->peeraddr, AF_INET);
    my $port = $client->peerport;
    while (<$client>) {
        print “[$name $port] $_”;
        print $client “$.: $_”;
$r = $_;
if( $r =~ /Movimento/) {
print $r,”\n”;
        system(“echo ‘$r’ > /tmp/test.txt”);
        open ($arquivo, ‘</var/lib/asterisk/agi-bin/telefones.txt’);
        while (<$arquivo>) {
           $numero = $_;
           my $discar = “/var/spool/asterisk/”.$numero.”.call”;
           my $arqdestino = “/var/spool/asterisk/outgoing/” ;
           open(EXTEN,”>$discar”);
           print EXTEN “Channel: Sip/$numero\n”;
           print EXTEN “MaxRetries: 5\n”;
           print EXTEN “RetryTime: 60 \n”;
           print EXTEN “WaitTime: 60 \n”;
           print EXTEN “Context: Saida\n”;
           print EXTEN “Extension: 3300\n”;
           print EXTEN “Priority: 1\n”;
           close(EXTEN);
           system(“mv /var/spool/asterisk/*.call $arqdestino”);
       }
       close $arquivo;

        }
 

}
    close $client
        or die “cliente encerrou conexao ($!)\n”;
}
die “socket com problema ($!)\n”;

 
###FIM###
 
 
[]’s
 
Eng Eder de Souza