def __init__(self, processNoiseCovariance=1e-2, measurementNoiseCovariance=1e-1, errorCovariancePost=0.1):
'''
Constructs a new Kalman2D object.
For explanation of the error covariances see
http://en.wikipedia.org/wiki/Kalman_filter
'''
self.kalman = cv.CreateKalman(4, 2, 0)
self.kalman_state = cv.CreateMat(4, 1, cv.CV_32FC1)
self.kalman_process_noise = cv.CreateMat(4, 1, cv.CV_32FC1)
self.kalman_measurement = cv.CreateMat(2, 1, cv.CV_32FC1)
for j in range(4):
for k in range(4):
self.kalman.transition_matrix[j,k] = 0
self.kalman.transition_matrix[j,j] = 1
cv.SetIdentity(self.kalman.measurement_matrix)
cv.SetIdentity(self.kalman.process_noise_cov, cv.RealScalar(processNoiseCovariance))
cv.SetIdentity(self.kalman.measurement_noise_cov, cv.RealScalar(measurementNoiseCovariance))
cv.SetIdentity(self.kalman.error_cov_post, cv.RealScalar(errorCovariancePost))
self.predicted = None
self.esitmated = None
def save(self, filename, cropFlag = False):
"""save cropped and rotated image"""
if not cropFlag:
cv.SaveImage(filename +'-vectors.png',self.render())
else:
tmp = rotate(self.cImage, self.center, self.cardinalOffset +\
self.north)
#mask horizon
mask = cv.CreateImage(self.res, 8, 1)
cv.Zero(mask)
cv.Circle(mask, self.center, self.radius, (255,255,255))
cv.FloodFill(mask,(1,1),(0,0,0))
cv.FloodFill(mask, self.center,
(255,255,255),lo_diff=cv.RealScalar(5))
masked = cv.CloneImage(tmp)
cv.Zero(masked)
cv.Copy(tmp, masked, mask)
cv.SaveImage(filename +'-cropped.png',crop(masked, self))
#CSV output
array = magnitudeToTheta(self.polarArray,self.radius)
f = open(filename + '.csv', 'w')
f.write('00\n')
f.write(','.join([str(v[0]) for v in array]))
f.write('\n')
f.write(','.join([str(v[1]) for v in array]))
f.write('\n')
f.flush()
f.close()
def getData():
for i in range (0 , classes):
for j in range (0, train_samples):
if j < 10 :
fichero = "OCR/"+str(i) + "/"+str(i)+"0"+str(j)+".pbm"
else:
fichero = "OCR/"+str(i) + "/"+str(i)+str(j)+".pbm"
src_image = cv.LoadImage(fichero,0)
prs_image = preprocessing(src_image, size, size)
row = cv.GetRow(trainClasses, i*train_samples + j)
cv.Set(row, cv.RealScalar(i))
row = cv.GetRow(trainData, i*train_samples + j)
img = cv.CreateImage( ( size, size ), cv.IPL_DEPTH_32F, 1)
cv.ConvertScale(prs_image,img,0.0039215, 0)
data = cv.GetSubRect(img, (0,0, size,size))
row1 = cv.Reshape( data, 0, 1 )
cv.Copy(row1, row)
def __init__(self,
initial_val=[0],
p_noise=[1e-2],
m_noise=[1e-3],
m_mat=[1],
ecv=[1]):
self.kalman = cv.CreateKalman(len(initial_val), len(initial_val), 0)
self.measurement = cv.CreateMat(len(initial_val), 1, cv.CV_32FC1)
self.prediction = None
cv.Zero(self.measurement)
cv.SetIdentity(self.kalman.measurement_matrix, cv.RealScalar(*m_mat))
cv.SetIdentity(self.kalman.process_noise_cov, cv.RealScalar(*p_noise))
cv.SetIdentity(self.kalman.measurement_noise_cov,
cv.RealScalar(*m_noise))
cv.SetIdentity(self.kalman.error_cov_post, cv.RealScalar(*ecv))
for v in initial_val:
self.kalman.state_post[initial_val.index(v), 0] = v
self.kalman.state_pre[initial_val.index(v), 0] = v
def on_mouse( event, x, y, flags, param ):
if( not color_img ):
return;
if event == cv.CV_EVENT_LBUTTONDOWN:
my_mask = None
seed = (x,y);
if ffill_case==0:
lo = up = 0
flags = connectivity + (new_mask_val << 8)
else:
lo = lo_diff;
up = up_diff;
flags = connectivity + (new_mask_val << 8) + cv.CV_FLOODFILL_FIXED_RANGE
b = random.randint(0,255)
g = random.randint(0,255)
r = random.randint(0,255)
if( is_mask ):
my_mask = mask
cv.Threshold( mask, mask, 1, 128, cv.CV_THRESH_BINARY );
if( is_color ):
color = cv.CV_RGB( r, g, b );
comp = cv.FloodFill( color_img, seed, color, cv.CV_RGB( lo, lo, lo ),
cv.CV_RGB( up, up, up ), flags, my_mask );
cv.ShowImage( "image", color_img );
else:
brightness = cv.RealScalar((r*2 + g*7 + b + 5)/10);
comp = cv.FloodFill( gray_img, seed, brightness, cv.RealScalar(lo),
cv.RealScalar(up), flags, my_mask );
cv.ShowImage( "image", gray_img );
print "%g pixels were repainted" % comp[0]
if( is_mask ):
cv.ShowImage( "mask", mask );
def findY(imgSrc):
mini = 0
maxi = 0
minFound = 0
maxVal=cv.RealScalar(imgSrc.width * 255)
for i in range(0,imgSrc.height):
data = cv.GetRow(imgSrc, i);
val = cv.Sum(data);
if(val[0] < maxVal[0]):
maxi = i
if(not minFound):
mini = i
minFound= 1
return mini,maxi
leftFingerDown = False
rightFingerDown = False
finger0initX = None
#jumlah jari yang akan dipakai
totalJari = 3
#karena resolusi kamera dan layar tidak sama diperlukan perbandingan
xScale = 2 #4.26
yScale = 2 #3.2
counter = 0
# definition of some colors
_red = (0, 0, 255, 0)
_green = (0, 255, 0, 0)
_white = cv.RealScalar(255)
_black = cv.RealScalar(0)
t0 = time.time()
while True:
currentFrame = cv.QueryFrame(capture)
currentFrameSize = (currentFrame.width, currentFrame.height)
cvImage = cv.CreateImageHeader(currentFrameSize, cv.IPL_DEPTH_8U, 3)
cv.SetData(cvImage, currentFrame.tostring())
cv.ShowImage("camera", cvImage)
if cv.WaitKey(10) == 13:
break
cv.DestroyWindow("camera")
while True:
if __name__ == "__main__":
A = [[1, 1], [0, 1]]
img = cv.CreateImage((500, 500), 8, 3)
kalman = cv.CreateKalman(2, 1, 0)
state = cv.CreateMat(2, 1, cv.CV_32FC1) # (phi, delta_phi)
process_noise = cv.CreateMat(2, 1, cv.CV_32FC1)
measurement = cv.CreateMat(1, 1, cv.CV_32FC1)
rng = cv.RNG(-1)
code = -1L
cv.Zero(measurement)
cv.NamedWindow("Kalman", 1)
while True:
cv.RandArr(rng, state, cv.CV_RAND_NORMAL, cv.RealScalar(0),
cv.RealScalar(0.1))
kalman.transition_matrix[0, 0] = 1
kalman.transition_matrix[0, 1] = 1
kalman.transition_matrix[1, 0] = 0
kalman.transition_matrix[1, 1] = 1
cv.SetIdentity(kalman.measurement_matrix, cv.RealScalar(1))
cv.SetIdentity(kalman.process_noise_cov, cv.RealScalar(1e-5))
cv.SetIdentity(kalman.measurement_noise_cov, cv.RealScalar(1e-1))
cv.SetIdentity(kalman.error_cov_post, cv.RealScalar(1))
cv.RandArr(rng, kalman.state_post, cv.CV_RAND_NORMAL, cv.RealScalar(0),
cv.RealScalar(0.1))
while True:
def __init__(self, cov, dynam_params, measure_params, control_params=0):
self.kf = cv.CreateKalman(dynam_params, measure_params, control_params)
cv.SetIdentity(self.kf.measurement_matrix, cv.RealScalar(1))
self.set_cov(cv.fromarray(cov))
