UFRN - Universidade Federal do Rio Grande do Norte

CT - Centro de Tecnologia
DCA - Departamenteo de Engenharia de Computação e Automação

Relatório Computação Numérica

Haroldo de Carvalho
Nicole Rieckmann

Queda da Bolinha
• Introdução

O experimento consiste em fazer um vídeo de uma bolinha

sendo solta de uma determinada altura e, posteriormente,
comparar os dados obtidos nesse vídeo com os dados pelo
respectivo método computacional.

Primeiramente, marcamos a altura de 2 metros como ponto

inicial da queda da bolinha e o chão, zero, como ponto final. Para
podermos testar se o método nos dará resultados similares aos reais
-obtidos no vídeo- dividimos a distância do ponto inicial ao final em
espaços de vinte em vinte centímetros.

O método utilizado é o Range-Kutta de 4ª Ordem para

Equações Diferenciais.

Os cálculos baseiam-se no Movimento de Queda Livre,

portanto a equação a ser utilizada no método d Range-Kutta é:

y = y0 + v0*t - (1/2)*g*(t^2), simplificando,

y = - (1/2)*g*(t^2), a velocidade inicial é zero.

Calculando a derivada em relação ao tempo, temos que

dy/dt = g*t = u(t), teremos, portanto:

d(u(x))/dx = f(x,u,v) e d(v(x))/dx = g(x,u,v).

 • O Algoritmo utilizado:

function [z] = f(x,u,v)

z = v;
endfunction

function [z] = g(x,u,v)

z = 9.8;
endfunction

//Metodo de RangeKutta

a = 0.0; //tempo inicial (em segundos)

u = 2; //Valor inicial de u
b = 0.634; //tempo final (em segundos)
v = 0; //Valor inicial de v
h = 0.04; //Passo da iteracao

function[x,u] = rk4ed(a,b,h,u,v)
n =(ba)/
h;
x(1) = a;
u(1) = u;
v(1) = v;
for k = 1:n
f1 = f(x(k),u(k),v(k));
g1 = g(x(k),u(k),v(k));
g2 = g(x(k)+(h/2),u(k)+(h/2)*f1,v(k)+(h/2)*g1);
f2 = f(x(k) + (h/2),u(k) + (h/2)*f1,v(k) + (h/2)*g1);
g3 = g(x(k)+(h/2),u(k)+(h/2)*f2,v(k)+(h/2)*g2);
f3 = f(x(k) + (h/2),u(k) + (h/2)*f2,v(k) + (h/2)*g2);
f4 = f(x(k) + h,u(k) + h*f3,v(k) + h*g3);
g4 = g(x(k) +h,u(k) + h*f3,v(k)+h*g3);
x(k + 1) = x(k) + h;
u(k + 1) = u(k) + (h/6)*(f1+2*f2+2*f3+f4);
v(k + 1) = v(k) + (h/6)*(g1+2*g2+2*g3+g4);
printf("[x(k),u(k)] = [%f,%f]\n",x(k),u(k))
end

distanciaReal = [2 ;1.93 ;1.78 ;1.52 ;1.17 ;0.71 ;0.18];

tempoReal = [0.0; 0.1; 0.2; 0.3; 0.4; 0.5; 0.6];

plot(x , u ,"diamondred");
plot(tempoReal,distanciaReal);
xtitle("Grafico de t vs h","tempo(s)","altura(m)");
endfunction
 • Dados

Inicio: t = 0.0s
Final: t = 0.634s

Amostra:

t = 0.000s ; s = 2.00m
t = 0.100s ; s = 1.93m
t = 0.200s ; s = 1.78m
t = 0.300s ; s = 1.52m
t = 0.400s ; s = 1.17m
t = 0.500s ; s = 0.71m
t = 0.600s ; s = 0.18m

• Gráficos

Gráfico do experimento
 Gráfico plotado do método de Range-Kutta4ed

• Conclusão
O vídeo serve como parâmetro real, ou seja, podemos determinar
aproximadamente a altura e em qual tempo a bolinha está, pausando o vídeo. E, então,
comparar ao cálculo realizado pelo método computacional. Como a precisão do cálculo
pode ser bem maior que a precisão dos nossos instrumentos de medição -que tem
limitações- o cálculo se aproxima bastante aos valores reais.

Reconstrução da Imagem Degradada

• Introdução
O intuito da reconstrução da Imagem consiste em recuperar pontos danificados de
uma imagem, modificando-os para obter um resultado próximo do original -sem os
respectivos defeitos.

Neste caso, utilizamos uma foto P&B (tons de preto), criamos falhas em uma
determinada imagem, e reconstruímos a imagem.

Foi utilizada a linguagem de programação C++ e OpenCV para realizar o tratamento

na imagem, portanto será utilizado o conhecimento dos métodos numéricos, o conjunto de
funções já pré-definidas no OpenCV.
 • O Algoritmo utlizado
#include <iostream>
#include "cv.h"
#include "highgui.h"

using namespace cv;

int main(int argc, char** argv){

Mat image, image1, mask;
int width, height;

image = imread("imagem.png",-1);
mask = imread("mascara.png",-1);

std::cout << "channels =" << image.channels() << "\n";

if(!image.data){
std::cout << "imagem nao carregou corretamente\n";
return(-1);
}

width=image.size().width;
height=image.size().height;
imshow("original", image);
image.convertTo(image1,CV_32F);
image1.convertTo(image,CV_32F);

while(1){
for(int i=0; i<height; i++){
for(int j = 0; j < width; j++){
//if(i==0){
if( (j == 0) && (mask.at<uchar>(i, j) == 0) )
image1.at<float>(i, j) = ( image.at<float>(i, j + 1) + image.at<float>(i + 1, j) ) / 2;
else if( (j == height - 1) && (mask.at<float>(i, j) == 0) )
image1.at<float>(i, j) = ( image.at<float>(i, j - 1) + image.at<float>(i + 1, j) ) / 2;
else if(mask.at<float>(i, j) == 0)
image1.at<float>(i, j) = ( image.at<float>(i, j + 1) + image.at<float>(i + 1, j)
+ image.at<float>(i, j - 1) ) / 3;
//} else if(j == 0) {
if( (i == 0) && (mask.at<uchar>(i, j) == 0) )
image1.at<float>(i, j) = ( image.at<float>(i + 1, j) + image.at<float>(i, j + 1) ) / 2;
else if( (i == width - 1) && (mask.at<float>(i, j) == 0) )
image1.at<float>(i, j) = ( image.at<float>(i - 1, j) + image.at<float>(i, j + 1) ) / 2;
else if(mask.at<float>(i, j) == 0)
image1.at<float>(i, j) = ( image.at<float>(i + 1, j) + image.at<float>(i, j + 1)
+ image.at<float>(i - 1, j) ) / 3;
//else if(mask.at<float>(i, j) == 0)
// image1.at<float>(i, j) = ( image.at<float>(i, j + 1) + image.at<float>(i + 1, j)
+ image.at<float>(i - 1, j) + image.at<float>(i, j - 1) ) / 4;
//}//end-if-else
}//end-for
}//end-for
swap(image1, image);
image1.convertTo(im1,CV_8U);
if(waitKey(30) == 27) break;
}//end-while
imshow("processada", image);
 imshow("mascara",mask);
waitKey();

return 0;
}

• Conclusão
Infelizmente, tivemos problemas com o OpenCv, portanto não temos um exemplo
ainda. Porém, podemos constatar que por mais perfeito e detalhista que seja o método de
reconstrução da imagem, a imagem a olho nu pode ficar com as falhas imperceptíveis,
porém conforme a a diferença de cores e complexidade da imagem as imperfeições são
mais visíveis.

Interpolação do Movimento do Carrinho

• Introdução
O experimento consiste em soltar um carrinho de uma rampa
(superfície plana levemente inclinada) e comparar seus resultados com os
obtidos à base dos cálculos nos métodos computacionais.

Improvisamos, pela falta do carrinho, portanto utilizamos uma

bolinha no vídeo em questão.

O método computacional utilizado é o de Interpolação de

Lagrange.

//método que gera o polinômio.

function [soma] = pol_lagrange(T, M)

n = length(T);
x = poly(0,"x");
soma = 0;
for i = 1 : n
produto = 1;
for j = 1 : n
if (i <> j)
produto = produto*(xT(
j))/(T(i)T(
j));
end
end
soma = soma + M(i)*produto
end
endfunction

• Dados:

Inicio: t = 0.0s
Final: t = 2.0s

Amostra:

t = 0.000s ; s = 1.98m
t = 0.100s ; s = 1.97m
t = 0.200s ; s = 1.94m
t = 0.300s ; s = 1.91m
t = 0.400s ; s = 1.88m
t = 0.500s ; s = 1.82m
t = 0.600s ; s = 1.78m
t = 0.700s ; s = 1.72m
t = 0.800s ; s = 1.65m
t = 0.900s ; s = 1.59m
t = 1.000s ; s = 1.50m
t = 1.100s ; s = 1.40m
t = 1.200s ; s = 1.27m
t = 1.300s ; s = 1.16m
t = 1.400s ; s = 1.00m
t = 1.500s ; s = 0.86m
t = 1.600s ; s = 0.68m
t = 1.700s ; s = 0.54m
t = 1.800s ; s = 0.37m
t = 1.900s ; s = 0.20m
t = 2.000s ; s = 0.00m

• Conclusão

Assim como constatamos no experimento da queda livre da bolinha, podemos,

através de métodos computacionais, chegar a uma aproximação consideravelmente
precisa da posição da bolinha num determinado tempo, o que facilita bastante estudos
físicos e projetos de engenharia, dadas as limitações da realização manual dessa medição.