Python é uma linguagem de programação versátil, que tem a filosofia de simplificar o processo de criação de software permitindo que os programadores expressem seus programas utilizando menos linhas de código.

O Python é uma linguagem interpretada, isto é, o código fonte de um programa é passado a um software chamado de interpretador, que lê os comandos e os executa de acordo com o que está especificado no código. A interpretação é um método alternativo à compilação, no qual todo o código fonte é traduzido para a linguagem de máquina (código binário que o processador consegue entender), sendo executado diretamente sem a necessidade de um software intermediário. Durante a compilação, um outro software (o compilador) precisa ser acionado ao menos uma vez para realizar a tradução do código fonte. Mas, uma vez compilado, o programa se torna independente, e pode ser executado diretamente.

Em contrapartida, um programado feito em uma linguagem interpertrada precisa que o software interpretador seja acionado sempre que este for executado. O processo de interpretação pode resultar em uma redução no desempenho da execução do programa, já que é necessário executar vários outros comandos auxiliares no interpretador para cada comando contido no código fonte. A vantagem é que, em geral, é mais fácil portar programas em linguagens interpretadas. Programas compilados irão funcionar apenas na plataforma (Arquitetura de Processador e Sistema Operacional) para o qual eles foram compilados. Não adianta tentar rodar um programa compilado para funcionar em um processador ARM em um processador IA-32, as intruções contidas serão diferentes. Entretanto, caso exista um interpretador funcionando em ambas as arquiteturas, o mesmo código fonte pode ser executado sem alterações nas duas máquinas.

Além disso, existem técnicas que podem melhorar o desempenho de aplicações interpretadas. Técnicas como JIT (just-in-time compilation) e criação de códigos intermediários permitem que partes do programa sejam traduzidas ou compiladas de antemão à medida que necessário, fazendo com que essas aplicações tenham um desempenho mais próximo o de programas compilados. Essas técnicas são intermediárias entre um processo de interpretação puro e de compilação.

--Código Fonte do módulo Principal:

import cv2
import cv2.cv as cv
import numpy as np

#Funcao para ler arquivo de configuracao
def read_file(path, aux):
        file = open(path, 'rw')
        line = file.readline()
        line = line.split(" ")
        file.close()
        if len(line) == 3:
            return  np.array([int(numeric_string) for numeric_string in line], dtype=np.uint8)
        else:
            return aux


#Comeco do Programa
cap = cv2.VideoCapture(0)

posX  = 0
posY  = 0
lastX = 0
lastY = 0
scribble = np.zeros((480,640,3), np.uint8)


while(True):
    # Capturar frame
    ret, frame = cap.read()
 
    #Ler Max e Min do Arquivo
    hsv_min = read_file("min", np.array([0, 163, 160]))
    hsv_max = read_file("max", np.array([11, 255, 255]))

    #Tratamento da Imagem
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) 
    hsv_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    thresholded = cv2.inRange(hsv_frame, hsv_min, hsv_max)
    thresholded = cv2.GaussianBlur(thresholded, (9, 9), 0)

    #Detectar circulos
    circles = cv2.HoughCircles(thresholded, cv.CV_HOUGH_GRADIENT, 1, 20, param1=50, param2=30, minRadius=10, maxRadius=400)
   
    #Verificar se circulos foram encontrados
    if circles is not None:
        circles = np.uint16(np.around(circles))
     
#Plotar circulos na imagem
    for i in circles[0,:]:
        cv2.circle(frame,(i[0],i[1]),i[2],(0,255,0),2)
        cv2.circle(frame,(i[0],i[1]),2,(0,0,255),3)
        posX = i[0] #Salvando posicao do centro do ultimo circulo encontrado
        posY = i[1]

    #Plotando linhas entre as duas ultimas posicoes
    if lastX>0 and lastY>0 and posX>0 and posY>0 :
        cv2.line(scribble, (lastX, lastY), (posX, posY), (255,0,255), 3)

    #Adicionando linhas ao frame principal
        cv2.add(frame, scribble, frame) 
    #Salvando posicao do ultimo circulo encontrado
        lastX = posX
        lastY = posY
    #Mostrar Imagens
        cv2.imshow('frame', gray)
        cv2.imshow('frame2', thresholded)
        cv2.imshow('frame3', frame)

    #Detectar pressionamento da tecla q (quit, encerra o programa)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

#Liberar Recursos
cap.release()
cv2.destroyAllWindows()

Neste vídeo é apresentada a ideia de criar um programa auxiliar para ajustar a faixa de valores de cores de um objeto, permitindo que este seja isolado na imagem: www.youtube.com/watch?v=JcDZxohDq2w.

Esta ideia é aplicada com a criação de um programa em java (HSVCreator.jar), no qual é possível ajustar faixas de valores HSV para até que seja possível encontrar uma faixa que isole o objeto marcador. Este programa escreve dois arquivos: min e max, contendo 3 valores inteiros que representam os intervalos para o filtro da imagem. O programa contém uma caixa de texto na qual se deve especificar o local onde os arquivos serão salvos (os arquivos max e min devem estar no mesmo diretório do arquivo teste.py, que contém o código do programa de detecção), e um conjunto de barras para o ajuste dos valores H, S e V respectivamente.

A função read_file lê os arquivos, e os valores são passados a função cv2.inrange, que cria um bitmap definindo as posições cujos pixels estão dentro e fora da faixa de valores especificados.