Mais uma etapa chegando ao fim...

Como os leitores já devem ter percebido, estou postando com baixa frequência.

O motivo é o meu mestrado que está chegando ao fim, e como todo final de curso que se preze estou com muito o que fazer.

Minha previsão é terminar o mestrado em julho (com a defesa da minha dissertação).

Enquanto estou ocultado com as atividades do mestrado, não poderei dar a devida atenção aos meus blogs.

Espero contar com a compreensão de todos e que Deus esteja conosco hoje e sempre.

Mathematical Morphology using OpenCV

I did a post about mathematical morphology, I wrote about theory of mathematical morphology.

Now, I want to write about the functions of OpenCV* for manipulate the structural element and apply the operations of erosion and dilatation.

The following function creates the structural element:

IplConvKernel* cvCreateStructuringElementEx( int cols,
                                            int rows,
                                            int anchor_x,
                                            int anchor_y,
                                            int shape,
                                            int* values=NULL );

cols: Number of columns of the structural element

rows: Number of rows of the structural element

anchor_x: Horizontal offset relative to point of anchor, normally equal to 0 (zero)

anchor_y: Vertical offset relative to point of anchor, normally equal to 0 (zero)

shape: Type of structural element, possible values:

• CV_SHAPE_RECT, square element;
• CV_SHAPE_CROSS, element in disc;
  
• CV_SHAPE_ELLIPSE, elliptic element;
• CV_SHAPE_CUSTOM, element defined by user. In this case, the parameter values specifies the mask, delimiting the vicinity of the pixel in analysis.
  

values: Pointer to structural element defined by usuer, this parameter is used just for shape = CV_SHAPE_CUSTOM.

Function of erosion:

void cvErode( const CvArr* src, CvArr* dst,
             IplConvKernel* element=NULL, int iterations=1 );

Function of dilatation:

void cvDilate( const CvArr* src, CvArr* dst,
             IplConvKernel* element=NULL, int iterations=1 );

src: Input image;

dst: Output image;

element: Structural element. If it's NULL, the structural element is a square 3x3;

iterations: Number of times for apply the operation.

The interfaces for development in Python is the same, and all functions are very fast because they're implemented in C.

More informations here.


----------------------
* OpenCV (Open Computational Vision) is a API for development using Computational Vision. It's a very powerful set of functions for capture, processing and showing of images and videos.

Carro voador "popular"

Olhe o novo desejo que iremos ter aqui.

Nada mais de engarrafamentos, trânsito lento, ruas esburacadas, pneus furados, etc...

Basta mudar seu carro convencional por um SKYCAR.

Segue um vídeo do produto.



Vale lembrar que é necessário um brevê para pilotar o SKYCAR.

Tutorial Scilab - 5 [Operações Lógicas]

[English version here.]

Como eu acredito que a maioria dos leitores conhece algo sobre operações lógicas, não vamos dar uma aula sobre o assunto. Porém, é bom revisar algo.

Operações lógicas são usadas para analisar situações do tipo:

• 2 é maior que 3? - falso
• o vetor [1 2 3 4] é maior que o vetor [1 3 5]? - verdadeiro
• a palavra 'casa' é menor que 'cachorro'? - falso

As operações lógicas são aplicadas para manipular os resultados destas situações, por exemplo:

Eu tenho 22 anos, meu pai tem 52 e minha irmã tem 19.

Quem de nós é o mais velho?

Vamos criar uma solução geral para o problema.

• Se eu sou mais velho que meu pai e minha irmã então eu sou o mais velho.
• Se meu pai é mais velho que eu e minha irmã então ele é o mais velho.
• Se minha irmã é mais velha que eu e meu pai então ela é a mais velha.
  

O conector e é uma operação lógica.

Os operadores lógicos são usados com variáveis lógicas, estas por sua vez são variáveis que só assumem os valores verdadeiro ou falso.

As operações lógicas básicas são as seguintes: {não, ou, e}, em inglês: {not, or, and} (vamos usar a notação em inglês porque esta é a adotada na literatura em português, inclusive brasileiro).

A operação not é unária e as demais são binárias.

Vamos ver agora os resultados de cada operação.

NOT

• not(verdadeiro) = false
• not(false) = verdadeiro

AND

• falso and falso = falso
• falso and verdadeiro = falso
• verdadeiro and falso = falso
• verdadeiro and verdadeiro = verdadeiro

OR

• falso or falso = falso
• falso or verdadeiro = verdadeiro
• verdadeiro or false = verdadeiro
• verdadeiro or verdadeiro = verdadeiro

Agora um pequeno exemplo.

Se eu preciso de uma raquete e uma bola mas só tenho a raquete então eu não estou satisfeito. Porém, se eu preciso de uma bola de basquete ou de vôlei mas eu só tenho a de vôlei então eu já estou satisfeito.

Sobre os operadores no Scilab:

O operador '~' é o not.

O operador '|' é o or.

O operador '&' é o and.

As operações and e or podem ser aplicadas em vetores com as funções or(.) e and(.).

Agora os scripts:

-->x = 10;

-->y = 15;

-->z = x + y
z =

25.

-->(x > y) & (z > x) // x é menor que y então a primeira operação é falso
ans =

F

-->(x > y) | (z > x) // z é maior que x então a segunda operação é verdadeiro
ans =

T

-->~((x > y) & (z > x)) // o resultado é o inverso do primeiro resultado
ans =

T

-->~((x > y) | (z > x)) // o resultado é o inverso do segundo resultado
ans =

F


Os resultados são F (false - falso) ou T (true - verdadeiro) porque operações logicas fornecem resultados lógicos.

Se for necessário usar os valores lógicos diretamente:

-->r1 = %F
r1 =

F

-->r2 = %T
r2 =

T

-->and([r1 r2])
ans =

F

-->or([r1 r2])
ans =

T


Para fechar o post, se você usar operadores lógicos com variáveis numéricas, o Scilab interpreta 0 (zero) como falso e qualquer coisa diferente de zero como verdadeiro.

-->x = 0;

-->y = 2;

-->z = -5;

-->x | y | z
ans =

T

-->x & y & z
ans =

F

-->x & z
ans =

F

-->x & y
ans =

F

-->y & z
ans =

T

Voar sobre a água

Eu vi este post aqui e achei muito interessante.

Tudo se resume neste vídeo.



Vamos analisar um pouco a situação.

Lembram-se de quantidade de movimento? Pois bem, a quantidade de movimento da água para baixo é a mesma da pessoa para cima, de modo que quando é alcançada uma velocidade inicial suficiente, nós subimos (e bem alto como visto no vídeo).

Não vou dar uma aula de física aqui, mas caso alguém tenha a oportunidade de brincar com algo assim um dia, só recomendo que não se esqueça do seu próprio peso, pois a força que a água te joga para cima deve ser igual ao seu peso para te manter em cima e se você for voar para frente, não se esqueça de continuar a manter seu peso equilibrado.

Acervo de mídias digitais on line

O governo criou um portal que reune e disponibiliza arquivos de imagens, sons, textos e vídeos gratuitamente - Domínio Público.

O sistema, segundo o próprio portal, é desenvolvido em Software Livre (mais um ponto positivo).

O que achei muito útil é que os textos incluem bibliografia por áera do conhecimento (Administração, Economia, Arquitetura, Artes, Política, Saúde, Informática, Matemática, Física, Medicina, etc...) e também uma seção de teses e dissertações, também dividida por áreas do conhecimento.

Enfim, fiquei sabendo que este portal estava ameaçado de ser fechado por falta de acessos, então vamos acessar!

Canal do Vaticano no YouTube

Fonte aqui.

O Papa Bento XVI decidiu por criar um canal no YouTube: http://www.youtube.com/vatican, alguns bispos foram contra pois disseram que um local com vídeos de quaisquer natureza não é adequado para expor o Vaticano, porém o Papa disse: "Cristo também se 'rebaixou' para assumir a natureza humana" e concluiu dizendo que deseja estar onde as pessoas estão.

É bom ver que as autoridades da Igreja estão abrindo seus olhos para os novos meios de comunicação e estão adentrando neste "novo mundo".

Devemos sempre evoluir e criar novas tecnologias e recursos, porém sem a Luz de Deus não seremos capazes de chegar na verdadeira e completa evolução.

Convolution

What's convolution? Who studies functional analysis in mathematics or signal and/or image processing, they ask themselves: "what's convolution?" and now we'll try to show a light.

Give a generic function f(t), for example a signal of voice.

We want to analyze the similarity between f(t) and another function h(t) (known). The similarity should be calculated for all t, because we don't know the moment that f(t) is most similar to h(t).

Okay, now we know what we have to do, let's learn how we do.

We have a function f(t), the most similar function to f(t) is f(t) (obvious), so if we dislocate f(t) over itself, for each lag (t - s) we calculate the similarity between f(t) and f(t - s), the maximum similarity occurs for s = 0.

But, if we have the function f(t - a) (f(t) shifted to left of a), thus if we dislocate h(t) = f(t - a) over f(t) the similarity between f(t) and f(t - s), the maximum similarity occurs for s = -a.

If we have a function h(t) and we don't know the moments and the values of similarity between f(t) and h(t), then we need calculate the similarity for each t, and I say: this calculus is the convolution.

For finish, Why do we want to calculate the similarity between two functions?

Because we can find known patterns in given functions. Return to signal of voice, we can find phonemes (known patterns) over a captured signal.

--------------
The command in Scilab that calculates the convolution is convol().