def energy(b_tmp, image):
sky_mask = make_mask(b_tmp, image)
ground = np.ma.array(
image,
mask=cv2.cvtColor(cv2.bitwise_not(sky_mask), cv2.COLOR_GRAY2BGR)
).compressed()
sky = np.ma.array(
image,
mask=cv2.cvtColor(sky_mask, cv2.COLOR_GRAY2BGR)
).compressed()
ground.shape = (ground.size//3, 3)
sky.shape = (sky.size//3, 3)
sigma_g, mu_g = cv2.calcCovarMatrix(
ground,
None,
cv2.COVAR_NORMAL | cv2.COVAR_ROWS | cv2.COVAR_SCALE
)
sigma_s, mu_s = cv2.calcCovarMatrix(
sky,
None,
cv2.COVAR_NORMAL | cv2.COVAR_ROWS | cv2.COVAR_SCALE
)
y = 2
return 1 / (
(y * np.linalg.det(sigma_s) + np.linalg.det(sigma_g)) +
(y * np.linalg.det(np.linalg.eig(sigma_s)[1]) +
np.linalg.det(np.linalg.eig(sigma_g)[1]))
)
def calcJm(img, H):
h, w, c = img.shape
skysample = np.zeros((sum(H), 3))
gndsample = np.zeros((w * h - sum(H), 3))
ks = 0
kg = 0
for x in range(w):
for y in range(H[x]):
skysample[ks, 0] = img[y, x, 0]
skysample[ks, 1] = img[y, x, 1]
skysample[ks, 2] = img[y, x, 2]
ks = ks + 1
for y in range(h - H[x]):
gndsample[kg, 0] = img[y + H[x], x, 0]
gndsample[kg, 1] = img[y + H[x], x, 1]
gndsample[kg, 2] = img[y + H[x], x, 2]
kg = kg + 1
skycov, skymean = cv2.calcCovarMatrix(skysample,
cv2.COVAR_ROWS | cv2.COVAR_NORMAL)
gndcov, gndmean = cv2.calcCovarMatrix(gndsample,
cv2.COVAR_ROWS | cv2.COVAR_NORMAL)
skyret, skyeigval, skyeigvec = cv2.eigen(skycov, 1)
gndret, gndeigval, gndeigvec = cv2.eigen(gndcov, 1)
skyeigvalsum = sum(skyeigval)
gndeigvalsum = sum(gndeigval)
skydet = cv2.determinant(skycov)
gnddet = cv2.determinant(gndcov)
Jm = 1.0 / (skydet + gnddet + skyeigvalsum * skyeigvalsum +
gndeigvalsum * gndeigvalsum)
return (Jm)
def calculate_sky_energy(border, src_image):
# 制作天空图像掩码和地面图像掩码
sky_mask = make_sky_mask(src_image, border, 1)
ground_mask = make_sky_mask(src_image, border, 0)
# 扣取天空图像和地面图像
sky_image_ma = np.ma.array(src_image, mask = cv2.cvtColor(sky_mask, cv2.COLOR_GRAY2BGR))
ground_image_ma = np.ma.array(src_image, mask = cv2.cvtColor(ground_mask, cv2.COLOR_GRAY2BGR))
# 计算天空和地面图像协方差矩阵
sky_image = sky_image_ma.compressed()
ground_image = ground_image_ma.compressed()
sky_image.shape = (sky_image.size//3, 3)
ground_image.shape = (ground_image.size//3, 3)
sky_covar, sky_mean = cv2.calcCovarMatrix(sky_image, mean=None, flags=cv2.COVAR_ROWS|cv2.COVAR_NORMAL|cv2.COVAR_SCALE)
sky_retval, sky_eig_val, sky_eig_vec = cv2.eigen(sky_covar)
ground_covar, ground_mean = cv2.calcCovarMatrix(ground_image, mean=None,flags=cv2.COVAR_ROWS|cv2.COVAR_NORMAL|cv2.COVAR_SCALE)
ground_retval, ground_eig_val, ground_eig_vec = cv2.eigen(ground_covar)
gamma = 2 # 论文原始参数
sky_det = cv2.determinant(sky_covar)
#sky_eig_det = cv2.determinant(sky_eig_vec)
ground_det = cv2.determinant(ground_covar)
#ground_eig_det = cv2.determinant(ground_eig_vec)
sky_energy = 1 / ((gamma * sky_det + ground_det) + (gamma * sky_eig_val[0,0] + ground_eig_val[0,0]))
return sky_energy
def refine_sky(bopt, image):
sky_mask = make_mask(bopt, image)
ground = np.ma.array(image,mask=cv2.cvtColor(cv2.bitwise_not(sky_mask), cv2.COLOR_GRAY2BGR)).compressed()
sky = np.ma.array(image,mask=cv2.cvtColor(sky_mask, cv2.COLOR_GRAY2BGR)).compressed()
ground.shape = (ground.size//3, 3)
sky.shape = (sky.size//3, 3)
ret, label, center = cv2.kmeans(np.float32(sky),2,None,(cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0),10,cv2.KMEANS_RANDOM_CENTERS)
sigma_s1, mu_s1 = cv2.calcCovarMatrix(sky[label.ravel() == 0],None,cv2.COVAR_NORMAL | cv2.COVAR_ROWS | cv2.COVAR_SCALE)
ic_s1 = cv2.invert(sigma_s1, cv2.DECOMP_SVD)[1]
sigma_s2, mu_s2 = cv2.calcCovarMatrix(sky[label.ravel() == 1],None,cv2.COVAR_NORMAL | cv2.COVAR_ROWS | cv2.COVAR_SCALE)
ic_s2 = cv2.invert(sigma_s2, cv2.DECOMP_SVD)[1]
sigma_g, mu_g = cv2.calcCovarMatrix(ground,None,cv2.COVAR_NORMAL | cv2.COVAR_ROWS | cv2.COVAR_SCALE)
icg = cv2.invert(sigma_g, cv2.DECOMP_SVD)[1]
if cv2.Mahalanobis(mu_s1, mu_g, ic_s1) > cv2.Mahalanobis(mu_s2, mu_g, ic_s2):
mu_s = mu_s1
sigma_s = sigma_s1
ics = ic_s1
else:
mu_s = mu_s2
sigma_s = sigma_s2
ics = ic_s2
for x in range(image.shape[1]):
cnt = np.sum(np.less(spatial.distance.cdist(image[0:bopt[x], x],mu_s,'mahalanobis',VI=ics),spatial.distance.cdist(image[0:bopt[x], x],mu_g,'mahalanobis',VI=icg)))
if cnt < (bopt[x] / 2):bopt[x] = 0
return bopt
def _get_orientation(self, pts):
# Construct a buffer used by the PCA analysis
data_pts = np.squeeze(np.array(pts, dtype=np.float64))
# Perform PCA analysis
# https://stackoverflow.com/questions/22612828/python-opencv-pcacompute-eigenvalue
covar, mean = cv2.calcCovarMatrix(
data_pts, np.mean(data_pts, axis=0),
cv2.COVAR_SCALE | cv2.COVAR_ROWS | cv2.COVAR_SCRAMBLED)
eigenvalues, eigenvectors = cv2.eigen(covar)[1:]
eigenvectors = cv2.gemm(eigenvectors, data_pts - mean, 1, None, 0)
eigenvectors = np.apply_along_axis(
lambda n: cv2.normalize(n, dst=None).flat, 1, eigenvectors)
# Store the centre of the object
cntr = np.array([int(mean[0, 0]), int(mean[0, 1])])
self.centres.append(cntr)
# Draw the principal components
cv2.circle(self.img, (cntr[0], cntr[1]), 3, (255, 0, 255), 1)
p1 = cntr + 0.02 * eigenvectors[0] * eigenvalues[0]
p2 = cntr - 0.02 * eigenvectors[1] * eigenvalues[1]
# self._draw_axis(copy.copy(cntr), p1, (0, 255, 0), 2)
# self._draw_axis(copy.copy(cntr), p2, (255, 255, 0), 10)
return np.arctan2(eigenvectors[0, 1],
eigenvectors[0, 0]) # orientation in radians
def performPCA(images):
# Allocate space for all images in one data matrix. The size of the data matrix is
# ( w * h * c, numImages ) where, w = width of an image in the dataset.
# h = height of an image in the dataset. c is for the number of color channels.
numImages = len(images)
sz = images[0].shape
channels = 1 # grayescale
data = np.zeros((numImages, sz[0] * sz[1] * channels), dtype=np.float32)
# store images as floating point vectors normalized 0 -> 1
for i in range(0, numImages):
image = np.float32(images[i])/255.0
data[i,:] = image.flatten() # N.B. data is stored as rows
# compute the eigenvectors from the stack of image vectors created
mean, eigenVectors = cv2.PCACompute(data, mean=None, maxComponents=args.eigenfaces)
# use the eigenvectors to project the set of images to the new PCA space representation
coefficients = cv2.PCAProject(data, mean, eigenVectors)
# calculate the covariance and mean of the PCA space representation of the images
# (skipping the first N eigenfaces that often contain just illumination variance, default N=3 )
covariance_coeffs, mean_coeffs = cv2.calcCovarMatrix(coefficients[:,args.eigenfaces_to_skip:args.eigenfaces], mean=None, flags=cv2.COVAR_NORMAL | cv2.COVAR_ROWS, ctype = cv2.CV_32F)
return (mean, eigenVectors, coefficients, mean_coeffs, covariance_coeffs)
def true_sky(border, src_image):
#制作天空图像掩码和地面图像掩码
sky_mask = make_sky_mask(src_image, border, 1)
ground_mask = make_sky_mask(src_image, border, 0)
#扣取天空图像和地面图像
sky_image_ma = np.ma.array(src_image, mask = cv2.cvtColor(sky_mask, cv2.COLOR_GRAY2BGR))
ground_image_ma = np.ma.array(src_image, mask = cv2.cvtColor(ground_mask, cv2.COLOR_GRAY2BGR))
#将天空和地面区域shape转换为n*3
sky_image = sky_image_ma.compressed()
ground_image = ground_image_ma.compressed()
sky_image.shape = (sky_image.size//3, 3)
ground_image.shape = (ground_image.size//3, 3)
# k均值聚类调整天空区域边界--2类
sky_image_float = np.float32(sky_image)
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0)
flags = cv2.KMEANS_RANDOM_CENTERS
compactness, labels, centers = cv2.kmeans(sky_image_float, 2, None, criteria, 10, flags)
sky_label_0 = sky_image[labels.ravel() == 0]
sky_label_1 = sky_image[labels.ravel() == 1]
sky_covar_0, sky_mean_0 = cv2.calcCovarMatrix(sky_label_0, mean= None, flags= cv2.COVAR_ROWS + cv2.COVAR_NORMAL + cv2.COVAR_SCALE)
sky_covar_1, sky_mean_1 = cv2.calcCovarMatrix(sky_label_1, mean= None, flags= cv2.COVAR_ROWS + cv2.COVAR_NORMAL + cv2.COVAR_SCALE)
ground_covar, ground_mean = cv2.calcCovarMatrix(ground_image, mean= None, flags= cv2.COVAR_ROWS + cv2.COVAR_NORMAL + cv2.COVAR_SCALE)
ic_s0 = cv2.invert(sky_covar_0, cv2.DECOMP_SVD)[1]
ic_s1 = cv2.invert(sky_covar_1, cv2.DECOMP_SVD)[1]
ic_g = cv2.invert(ground_covar, cv2.DECOMP_SVD)[1]
#推断真实的天空区域
if cv2.Mahalanobis(sky_mean_0, ground_mean, ic_s0) > cv2.Mahalanobis(sky_mean_1, ground_mean, ic_s1):
sky_mean = sky_mean_0
sky_covar = sky_covar_0
ic_s = ic_s0
else:
sky_mean = sky_mean_1
sky_covar = sky_covar_1
ic_s = ic_s1
return sky_covar,sky_mean,ic_s,ground_covar, ground_mean,ic_g
def similarity_transform(shape10,shape20):
shape1=np.zeros((shape10.shape[0]))
shape1[:]=shape10[:]
shape2=np.zeros((shape20.shape[0]))
shape2[:]=shape20[:]
center_x1=np.mean(shape1[::2])
center_y1=np.mean(shape1[1::2])
center_x2=np.mean(shape2[::2])
center_y2=np.mean(shape2[1::2])
shape1[::2]=shape1[::2]-center_x1
shape1[1::2]=shape1[1::2]-center_y1
shape2[::2]=shape2[::2]-center_x2
shape2[1::2]=shape2[1::2]-center_y2
temp1=np.zeros((2,shape10.shape[0]/2))
temp2=np.zeros((2,shape20.shape[0]/2))
temp1[0,:]=shape1[::2]
temp1[1,:]=shape1[1::2]
temp2[0,:]=shape2[::2]
temp2[1,:]=shape2[1::2]
covar1,m1=cv2.calcCovarMatrix(temp1.T,cv2.cv.CV_COVAR_COLS)
covar2,m2=cv2.calcCovarMatrix(temp2.T,cv2.cv.CV_COVAR_COLS)
#covar1=np.cov(temp1,rowvar=1)
#covar2=np.cov(temp2,rowvar=1)
s1=np.sqrt(np.linalg.norm(covar1))
s2=np.sqrt(np.linalg.norm(covar2))
#s11=np.sqrt(np.linalg.norm(haha1))
#s22=np.sqrt(np.linalg.norm(haha2))
scale = s1 / s2
"""
aaa= np.sum(np.abs(shape1-shape2 ))
bbb= np.sum(np.abs(scale*shape2-shape1 ))
if (aaa>bbb):
print "right"
else: print "wrong"
"""
shape1=shape1/s1
shape2=shape2/s2
num=np.sum(shape1[::2]*shape2[1::2]-shape1[1::2]*shape2[::2])
den=np.sum(shape1[::2]*shape2[::2]+shape1[1::2]*shape2[1::2])
norm=np.sqrt(num*num+den*den)
sin_theta = num/norm
cos_theta = den/norm
tran=np.array([[scale*cos_theta,scale*sin_theta],[-scale*sin_theta,scale*cos_theta]])
return tran
def get_similarity_transform(shape_from, shape_to):
rotation = np.zeros((2, 2))
scale = 0.
center_x_1, center_y_1 = np.mean(shape_to, axis=0)
center_x_2, center_y_2 = np.mean(shape_from, axis=0)
center_x_1 /= shape_to.shape[0]
center_y_1 /= shape_to.shape[0]
center_x_2 /= shape_from.shape[0]
center_y_2 /= shape_from.shape[0]
temp1 = shape_to.copy()
temp2 = shape_from.copy()
temp1 -= np.array([center_x_1, center_y_1]).reshape((1, 2))
temp2 -= np.array([center_x_2, center_y_2]).reshape((1, 2))
covariance1, mean1 = cv.calcCovarMatrix(temp1, None, cv.COVAR_COLS)
# print("cov mean:", covariance1, mean1)
covariance2, mean2 = cv.calcCovarMatrix(temp2, None, cv.COVAR_COLS)
s1, s2 = np.sqrt(np.linalg.norm(covariance1)), np.sqrt(
np.linalg.norm(covariance2))
scale = s1 / s2
temp1 /= s1
temp2 /= s2
num = 0.
den = 0.
for t1, t2 in zip(temp1, temp2):
num += t1[1] * t2[0] - t1[0] * t2[1]
den += t1[0] * t2[0] + t1[1] * t2[1]
norm = np.sqrt(num * num + den * den)
sin_theta = num / norm
cos_theta = den / norm
rotation[0, 0] = cos_theta
rotation[0, 1] = -sin_theta
rotation[1, 0] = sin_theta
rotation[1, 1] = cos_theta
# print("rot scale", rotation, scale)
return rotation, scale
def calcNormEigenVals(pts):
"""
descriptor of the binary image by using eigen values
:param pts: inpoints
:return:
"""
covar, mean = cv2.calcCovarMatrix(pts,
mean=None,
flags=cv2.COVAR_NORMAL | cv2.COVAR_ROWS
| cv2.COVAR_SCALE)
ret, eVal, eVec = cv2.eigen(covar)
eSum = eVal[0] + eVal[1]
eVal1 = eVal[0] / eSum
eVal2 = eVal[1] / eSum
return eVal1, eVal2
def getModel(imgs, points, directions, n):
profiles = np.zeros((points.shape[0], points.shape[1], 2 * n + 1))
for p in range(points.shape[1]):
profiles[:, p, :] = getProfilesForPerson(imgs[p], points[:, p, :],
directions[:, p, :], n)
covars = np.zeros((points.shape[0], 2 * n + 1, 2 * n + 1))
means = np.zeros((points.shape[0], 2 * n + 1))
for l in range(points.shape[0]):
[covars[l], means[l]
] = cv2.calcCovarMatrix(profiles[l, :, :] * 1.0,
cv2.cv.CV_COVAR_NORMAL | cv2.cv.CV_COVAR_ROWS)
return covars, means
def PCA(PCAInput):
# The following mimics PCA::operator() implementation from OpenCV's
# matmul.cpp() which is wrapped by Python cv2.PCACompute(). We can't
# use PCACompute() though as it discards the eigenvalues.
# Scrambled is faster for nVariables >> nObservations. Bitmask is 0 and
# therefore default / redundant, but included to abide by online docs.
covar, mean = cv2.calcCovarMatrix(PCAInput, cv2.cv.CV_COVAR_SCALE |
cv2.cv.CV_COVAR_ROWS |
cv2.cv.CV_COVAR_SCRAMBLED)
eVal, eVec = cv2.eigen(covar, computeEigenvectors=True)[1:]
# Conversion + normalisation required due to 'scrambled' mode
eVec = cv2.gemm(eVec, PCAInput - mean, 1, None, 0)
# apply_along_axis() slices 1D rows, but normalize() returns 4x1 vectors
eVec = np.apply_along_axis(lambda n: cv2.normalize(n).flat, 1, eVec)
return mean, eVec
def train(img_vec, eig_vec_num):
mean = np.mean(img_vec, 1)
# Calculate covariance matrix
pca_data = np.transpose(np.transpose(img_vec) - mean)
pca_mat = np.dot(np.transpose(pca_data), pca_data)
cov, temp_mean = cv2.calcCovarMatrix(pca_mat, mean,
cv2.COVAR_NORMAL | cv2.COVAR_ROWS)
# Eigenvectors and eigenvalues
eig_val_temp, eig_vec_temp = cv2.eigen(cov, eigenvectors=True)[1:]
eig_vec = np.dot(eig_vec_temp, np.transpose(img_vec))
eig_vec = (eig_vec - eig_vec.min()) / (eig_vec.max() - eig_vec.min())
eig_vec_mat = []
for idx in range(eig_vec_num):
eig_vec_mat.append(eig_vec[idx])
return mean, eig_vec_mat
def PCA(PCAInput):
# The following mimics PCA::operator() implementation from OpenCV's
# matmul.cpp() which is wrapped by Python cv2.PCACompute(). We can't
# use PCACompute() though as it discards the eigenvalues.
# Scrambled is faster for nVariables >> nObservations. Bitmask is 0 and
# therefore default / redundant, but included to abide by online docs.
covar, mean = cv2.calcCovarMatrix(
PCAInput, cv2.cv.CV_COVAR_SCALE | cv2.cv.CV_COVAR_ROWS
| cv2.cv.CV_COVAR_SCRAMBLED)
eVal, eVec = cv2.eigen(covar, computeEigenvectors=True)[1:]
# Conversion + normalisation required due to 'scrambled' mode
eVec = cv2.gemm(eVec, PCAInput - mean, 1, None, 0)
# apply_along_axis() slices 1D rows, but normalize() returns 4x1 vectors
eVec = np.apply_along_axis(lambda n: cv2.normalize(n).flat, 1, eVec)
return mean, eVec
def get_orientation(pts, img):
sz = len(pts)
data_pts = np.empty((sz, 2), dtype=np.float64)
for i in range(data_pts.shape[0]):
data_pts[i, 0] = pts[i, 0, 0]
data_pts[i, 1] = pts[i, 0, 1]
# Perform PCA analysis
mean = np.empty(0)
# mean, eigenvectors, eigenvalues = cv2.PCACompute2(data_pts, mean)
covar, mean = cv2.calcCovarMatrix(data_pts, mean, cv2.COVAR_SCALE |
cv2.COVAR_ROWS |
cv2.COVAR_SCRAMBLED)
eVal, eVec = cv2.eigen(covar)[1:]
# Conversion + normalisation required due to 'scrambled' mode
eVec = cv2.gemm(eVec, data_pts - mean, 1, None, 0)
# apply_along_axis() slices 1D rows, but normalize() returns 4x1 vectors
eVec = np.apply_along_axis(lambda n: cv2.normalize(n, n).flat, 1, eVec)
# Store the center of the object
# cntr2 = (int(mean[0, 0]), int(mean[0, 1]))
M = cv2.moments(pts)
cX = int(M["m10"] / M["m00"])
cY = int(M["m01"] / M["m00"])
cntr = (cX, cY)
cv2.circle(img, cntr, 3, (255, 0, 255), 2)
# p1 = (cntr[0] + 0.02 * eigenvectors[0, 0] * eigenvalues[0, 0],
# cntr[1] + 0.02 * eigenvectors[0, 1] * eigenvalues[0, 0])
# p2 = (cntr[0] - 0.02 * eigenvectors[1, 0] * eigenvalues[1, 0],
# cntr[1] - 0.02 * eigenvectors[1, 1] * eigenvalues[1, 0])
p1 = (cntr[0] + 0.02 * eVec[0, 0] * eVal[0, 0],
cntr[1] + 0.02 * eVec[0, 1] * eVal[0, 0])
p2 = (cntr[0] - 0.02 * eVec[1, 0] * eVal[1, 0],
cntr[1] - 0.02 * eVec[1, 1] * eVal[1, 0])
# draw_axis(img, cntr, p1, (0, 255, 0), 1)
# draw_axis(img, cntr, p2, (255, 255, 0), 5)
# angle = atan2(eigenvectors[0, 1], eigenvectors[0, 0]) # orientation in radians
angle = atan2(eVec[0, 1], eVec[0, 0])
return angle, cntr, eVec[0, 0], eVec[0, 1], eVal[0, 0]
def examine(self, frame, verticalTest=True, horizontalTest=True):
try:
frame_size = (frame.shape[1], frame.shape[0])
# frame1 = np.array(frame,dtype=np.float)
# rowSum = cv2.reduce(frame1,0,rtype = cv2.REDUCE_SUM)
# try:
# startX = frame_size[0]//2 - rowSum[:frame_size[0]//2][::-1].tolist().index(0)
# except:
# startX = 0
# pass
# try:
# endX = frame_size[0]//2 + rowSum[frame_size[0]//2:].tolist().index(0)
# except:
# endX = frame_size[0]
# pass
# if startX == endX:
# startX = 0
# endX = frame_size[0]
# points = cv2.findNonZero(frame[:,startX:endX])
points = cv2.findNonZero(frame)
stdDev = cv2.meanStdDev(points)[1]
points = np.array(points[:, 0, :], dtype=np.float)
mean = None
res2 = cv2.calcCovarMatrix(points, mean,
cv2.COVAR_ROWS + cv2.COVAR_NORMAL)
covM = res2[0]
corrCoef = covM[0, 1] / covM[0, 0]
# point = res2[1][0,0]+startX,res2[1][0,1]
point = res2[1][0, 0], res2[1][0, 1]
# Verifying the Pearson correlation coffecients, the vertical line or the horizontal line
isLinear = (np.abs(corrCoef) > self.inferiorCorrLimit) or (
horizontalTest and stdDev[0] < self.lineThinkness * 0.341
and stdDev[1] > frame_size[1] * 0.22) or (
verticalTest and stdDev[0] > frame_size[0] * 0.22
and stdDev[1] < self.lineThinkness * 0.341)
return isLinear, point, len(points)
except Exception as e:
print("Except", e)
return False, (0, 0)
def plotVariations(toothId=0, nbModes=15):
# Read data (images and landmarks)
landmarks = lm.readLandmarksOfTooth(toothId, trainingPersonIds)
# Initialization of mean vector (xStriped), covariance matrix, x-vector, x-striped-vector (mean), eigenvectors (P) and eigenvalues.
processedLandmarks = procrustes.procrustesMatrix(landmarks, 100)
mean, eigvec = cv2.PCACompute(np.transpose(
stackPoints(processedLandmarks)))
# Calculate the eigenvalues and sort them
covar, _ = cv2.calcCovarMatrix(
stackPoints(processedLandmarks), cv2.cv.CV_COVAR_SCRAMBLED
| cv2.cv.CV_COVAR_SCALE | cv2.cv.CV_COVAR_COLS)
eigval = np.sort(np.linalg.eigvals(covar), kind='mergesort')[::-1]
for mode in range(nbModes):
for var in [-3, 0, 3]:
tooth = mean + var * (eigval[mode]**0.5) * eigvec[mode]
tooth = unstackPointsForPerson(np.transpose(tooth))
# plot the tooth
pt.plotTooth(tooth)
# show the variations
pt.show()
def pca(X, nb_components=0):
'''
Do a PCA analysis on X
@param X: np.array containing the samples
shape = (nb samples, nb dimensions of each sample)
@param nb_components: the nb components we're interested in
@return: return the nb_components largest eigenvalues and eigenvectors of the covariance matrix and return the average sample
'''
[n,d] = X.shape
if (nb_components <= 0) or (nb_components>n):
nb_components = n
#calculate scrambled covariance matrix for increased performance
[covar, mean] = cv2.calcCovarMatrix(X, cv.CV_COVAR_SCALE | cv.CV_COVAR_ROWS | cv.CV_COVAR_SCRAMBLED)
#compute eigenvalues and vectors of scrambled covariance matrix
[retval,eigenvals,eigenvects] = cv2.eigen(covar, True)
#calculate the normal eigenvactors from the scrambled eigenvectors
eigenvects = cv2.gemm(eigenvects, X - mean, 1, None, 0)
eigenvects = np.apply_along_axis(lambda n: cv2.normalize(n).flat, 1, eigenvects)
# return the nb_components largest eigenvalues and eigenvectors
return [eigenvals[:n], np.transpose(eigenvects[:n]), np.transpose(mean)]
def ellipse_variance(contour):
'''
Calculate the ellipse variance
Parameters
----------
contour: OpenCV contour : Contour of the ROI
Returns
-------
ellipse variance
'''
ellipse = cv2.fitEllipse(contour)
poly =\
cv2.ellipse2Poly((int(ellipse[0][0]), int(ellipse[0][1])), (int(ellipse[1][0] / 2), int(ellipse[1][1] / 2)), int(ellipse[2]), 0, 360, 5)
poly = poly.astype('float64')
covar, _ = cv2.calcCovarMatrix(poly,
0,
flags=cv2.COVAR_NORMAL + cv2.COVAR_ROWS)
inv_covar = np.linalg.inv(covar + np.finfo(float).eps)
gravity = center_of_gravity(contour)
di = np.zeros((1, poly.shape[0]))
i = 0
mr = 0
for point in poly:
vt = point - gravity
v = np.transpose(vt)
d = np.sqrt(np.matmul(np.matmul(vt, inv_covar), v))
di[0, i] = d
mr += d
i += 1
mr = mr / i
di = di - mr
di = di * di
dr = np.sqrt(np.sum(di) / i)
return dr
def featureEng(inp):
'''
input: np array. #samples x #channels x widht and height
return: for each sample,
total brightness and std along the principle component
'''
Nf = 2 # num of features
(NN, Nl) = inp.shape[:2]
out = np.zeros((NN, Nf * Nl))
for i in range(NN):
if not (i % 10000):
print('Processing', i, '/', NN)
for j in range(Nl):
mat, _, _, ss = frame2matrix(inp[i, j, :, :])
if ss == 0:
out[i, j * Nf:j * Nf + Nf] = (0, 0)
continue
covar, _ = cv2.calcCovarMatrix(mat, np.array([0., 0.]),
cv2.COVAR_ROWS | cv2.COVAR_NORMAL)
_, _, eVec = cv2.eigen(covar)
proj = np.dot(eVec[0], mat.T)
out[i, j * Nf:j * Nf + Nf] = (ss, proj.std())
return out
#!/usr/bin/end python import numpy as np import cv2 import cv if __name__ == '__main__': m = np.asmatrix([[1,2],[1,2]], np.float32) print np.cov(m) covmat,mean = cv2.calcCovarMatrix(m, cv2.cv.CV_COVAR_NORMAL | cv2.cv.CV_COVAR_COLS, ctype=cv2.CV_32F) print covmat print mean
# 0423.py
import cv2
import numpy as np
X = np.array([[0, 0, 0, 100, 100, 150, -100, -150],
[0, 50, -50, 0, 30, 100, -20, -100]],
dtype=np.float64)
# 전치행렬 변경
X = X.transpose() # X = X.T
cov, mean = cv2.calcCovarMatrix(X,
mean=None,
flags=cv2.COVAR_NORMAL + cv2.COVAR_ROWS)
print('mean=', mean)
print('cov=', cov)
# 공분산 행렬 cov 의 역행렬 icov 계산
ret, icov = cv2.invert(cov)
print('icov=', icov)
v1 = np.array([[0], [0]], dtype=np.float64)
v2 = np.array([[0], [50]], dtype=np.float64)
# 벡터 v1, v2 사이의 마하라노비스 통계적 거리는 공분산 행렬의
# 역행렬을 이용해서 계산
dist = cv2.Mahalanobis(v1, v2, icov)
print('dist = ', dist)
cv2.waitKey()
cv2.destroyAllWindows()
#
# Q4: Calculate the Covariance Matrix of each of the groups.
#
flags = cv2.COVAR_NORMAL | cv2.COVAR_ROWS
grouped_data = []
icovariance = []
for c in range(0, 10):
grouped_data.append([])
for i in range(0, len(digits)):
if labels[i] == c:
grouped_data[c].append(digits[i])
print 'group:', c, len(grouped_data[c])
x = np.array(grouped_data[c])
covar, mean = cv2.calcCovarMatrix(x, flags)
icovar = np.empty(covar.shape, covar.dtype)
cv2.invert(covar, icovar, cv2.DECOMP_SVD)
icovariance.append(icovar)
#
# Q5: For each group, calculate the Mahalanobis distance of every element
# to the centroid, then draw the centroid followed by the three farthest
# elements (showing their Mahalanobis distance).
#
for index, centroid in enumerate(centroids):
points = np.float32(grouped_data[index])
icovar = np.float32(icovariance[index])
#
# Q4: Calculate the Covariance Matrix of each of the groups.
#
flags = cv2.COVAR_NORMAL | cv2.COVAR_ROWS
grouped_data = []
icovariance = []
for c in range(0, 10):
grouped_data.append([])
for i in range(0, len(digits)):
if labels[i] == c:
grouped_data[c].append(digits[i])
print 'group:', c, len(grouped_data[c])
x = np.array(grouped_data[c])
covar, mean = cv2.calcCovarMatrix(x, flags)
icovar = np.empty(covar.shape, covar.dtype)
cv2.invert(covar, icovar, cv2.DECOMP_SVD)
icovariance.append(icovar)
#
# Q5: For each group, calculate the Mahalanobis distance of every element
# to the centroid, then draw the centroid followed by the three farthest
# elements (showing their Mahalanobis distance).
#
for index, centroid in enumerate(centroids):
points = np.float32(grouped_data[index])
icovar = np.float32(icovariance[index])
mdistance = []
key = cv2.waitKey(10)
if key == 27:
break
elif key == ord('s'):
cv2.imwrite('eigenimages/image' + str(id) + '.png', image_toshow)
np.savetxt('eigenimages/image' + str(id) + '.txt', np.array(weights))
elif key == ord('r'):
for v in range(N):
cv2.setTrackbarPos("weight" + str(v), "Eigenimages", 100)
cv2.destroyAllWindows()
print('please wait ...')
covariance_matrix, mean = cv2.calcCovarMatrix(
images, None, cv2.COVAR_ROWS | cv2.COVAR_NORMAL | cv2.COVAR_SCALE)
_, eigenvalues, eigenvectors = cv2.eigen(covariance_matrix)
print('... done')
eigenvalues = np.reshape(eigenvalues, (eigenvalues.shape[0], ))
eigenvalues = np.abs(eigenvalues)
eigenvalues = np.flip(np.sort(eigenvalues))
plt.figure(figsize=[8, 6])
plt.plot(eigenvalues, 'r', linewidth=2.0)
plt.legend(['abs(eigenvalues)'], fontsize=18)
plt.xlabel('order ', fontsize=16)
plt.ylabel('abs', fontsize=16)
plt.title('Eigenvalues', fontsize=16)
plt.savefig('eigenimages\eigenvalues.png')
plt.figure(figsize=[8, 6])
dirName = "./step1/data/"
images = readImages(dirName)
print(len(images))
#Size of images
sz = images[0].shape
print(sz)
#Create data matrix for PCA
data = createDataMatrix(images)
print("Data")
print(data)
print("Calculating PCA ")
mean, eigenVectors = cv2.PCACompute(data,
mean=None,
maxComponents=NUM_EIGEN_FACES)
covar, mean2 = cv2.calcCovarMatrix(
data, 0, cv2.COVAR_SCALE | cv2.COVAR_ROWS | cv2.COVAR_SCRAMBLED)
print("Mean 1")
print(mean)
print("Mean 2")
print(mean2)
print("DONE")
print("Covar ", covar)
averageFace = mean2.reshape(sz)
eVal, eigenVectors2 = cv2.eigen(covar, True)[1:]
eigenFaces = []
for eigenVector in eigenVectors:
eigenFace = eigenVector.reshape(sz)
eigenFaces.append(eigenFace)
def plow(img):
diffImg = nonLocalGrouping(img)
diffImg = diffImg.reshape((-1, 1))
diffImg = np.float32(diffImg)
# Define criteria = ( type, max_iter = 10 , epsilon = 1.0 )
criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 10, 1.0)
K = 15
ret, label, center = cv.kmeans(diffImg, K, None, criteria, 10,
cv.KMEANS_RANDOM_CENTERS)
# Now convert back into uint8, and make original image
center = np.uint8(center)
res = center[label.flatten()]
kMeansRes = res.reshape((img.shape))
roi = cv.selectROI("Select ROI", img)
cv.destroyAllWindows()
noiseImg = img[int(roi[1]):int(roi[1] + roi[3]),
int(roi[0]):int(roi[0] + roi[2])]
#standard deviation of noise
std = np.std(noiseImg)
kernel = np.zeros((2, 2))
kernel[0][0] = 2
kernel[1][0] = -1
kernel[0][1] = -1
filtered = cv.filter2D(noiseImg, -1, kernel)
filtered = filtered.reshape((-1, 1))
filtered = np.float32(filtered)
filtered = filtered / math.sqrt(6)
delMed = np.median(filtered)
while delMed == 0:
min, max, minLoc, maxLoc = cv.minMaxLoc(filtered)
x = minLoc[0]
y = minLoc[1]
filtered[y, x] = max + 1
delMed = np.median(filtered)
delMed = abs(delMed)
# filtered = noiseImg - delMed
med = np.median(delMed)
sigma = 1.4826 * med
if sigma == 0:
return
h2 = 1.75 * pow(sigma, 2)
filtred = median(img.copy(), 5)
n = 5
identity = pow(sigma, 2) * np.identity(n)
height, width = img.shape
window = (n - 1) / 2
meanPatches = {}
divideWith = {}
covarianceSamples = {}
filteredWithBorder = np.zeros([int(height + n), int(width + n)], np.uint32)
filteredWithBorder[window:height + window, window:width + window] = img
imgWithBorder = filteredWithBorder
for x in range(width):
for y in range(height):
currX = x + window
currY = y + window
currentPatch = filteredWithBorder[int(currY -
window):int(currY + window +
1),
int(currX -
window):int(currX + window +
1)]
ret, divideWithCoeffs = cv.threshold(np.float32(currentPatch), 2,
1, cv.THRESH_BINARY)
if kMeansRes[y, x] in meanPatches:
meanPatches[kMeansRes[y, x]] = np.add(
meanPatches[kMeansRes[y, x]], currentPatch)
divideWith[kMeansRes[y,
x]] = np.add(divideWith[kMeansRes[y, x]],
divideWithCoeffs)
covHeight = -1
covWidth = -1
if (kMeansRes[y, x] in covarianceSamples):
covHeight, covWidth = covarianceSamples[kMeansRes[y,
x]].shape
if (covWidth < n and currX > 2 * window
and currX < width - (2 * window) and currY > 2 * window
and currY < height - (2 * window)):
currentPatch = currentPatch.reshape((-1, 1))
if kMeansRes[y, x] in covarianceSamples:
covarianceSamples[kMeansRes[y, x]] = np.hstack(
(covarianceSamples[kMeansRes[y, x]], currentPatch))
# covariances[kMeansRes[y, x]] = np.append(covariances[kMeansRes[y, x]], currentPatch, 1)
else:
covarianceSamples[kMeansRes[y, x]] = currentPatch
else:
meanPatches[kMeansRes[y, x]] = currentPatch
divideWith[kMeansRes[y, x]] = divideWithCoeffs
if (currX > 2 * window and currX < width - (2 * window)
and currY > 2 * window
and currY < height - (2 * window)):
currentPatch = currentPatch.reshape((-1, 1))
covarianceSamples[kMeansRes[y, x]] = currentPatch
toDel = []
for i in covarianceSamples:
covheight, covwidth = covarianceSamples[i].shape
if covwidth < n:
toDel.append(i)
for i in list(toDel):
del covarianceSamples[i]
del meanPatches[i]
covariances = {}
for key in meanPatches.keys():
currentPatch = meanPatches[key]
divideWithPatch = divideWith[key]
heightPatch, widthPatch = currentPatch.shape
for x in range(widthPatch):
for y in range(heightPatch):
currentPatch[y, x] = currentPatch[y, x] / divideWithPatch[y, x]
meanPatches[key] = currentPatch
meanOut = np.zeros(covarianceSamples[key].shape)
covMat, test2 = cv.calcCovarMatrix(np.float32(covarianceSamples[key]),
np.float32(meanOut),
cv.COVAR_NORMAL | cv.COVAR_ROWS)
covMat = covMat - identity
eigenVals, eigenVect = la.eig(covMat)
for x in range(eigenVals.size):
if eigenVals[x] < 0:
eigenVals[x] = 0.0001
eigenVals = np.real(eigenVals)
eigenVect = np.real(eigenVect)
covariances[key] = eigenVect * eigenVals * np.transpose(eigenVect)
resultImg = np.zeros(imgWithBorder.shape, np.uint64)
divideWith = np.zeros(filteredWithBorder.shape, np.uint64)
similarPatches = {}
#half of the actual size
searchWindow = 5
for x in range(width):
for y in range(height):
currX = x + window
currY = y + window
currClass = kMeansRes[y, x]
if currClass not in meanPatches:
continue
currentPatch = filteredWithBorder[int(currY -
window):int(currY + window +
1),
int(currX -
window):int(currX + window +
1)]
weights = []
patches = []
meanPatch = np.zeros(currentPatch.shape)
divideWithCoeffs = np.ones(currentPatch.shape)
sumWeights = np.ones(currentPatch.shape)
for k in range(width):
if k < x - searchWindow:
continue
if k > x + searchWindow:
break
for l in range(height):
if l < y - searchWindow:
continue
if l > y + searchWindow:
break
if (k != x and l != y and kMeansRes[l, k] == currClass):
currK = k + window
currL = l + window
comparePatch = filteredWithBorder[
int(currL - window):int(currL + window + 1),
int(currK - window):int(currK + window + 1)]
patchHeight, patchWidth = comparePatch.shape
for patchX in range(patchWidth):
for patchY in range(patchHeight):
if comparePatch[patchY, patchX] == 0:
comparePatch[patchY,
patchX] = currentPatch[patchY,
patchX]
elif currentPatch[patchY, patchX] == 0:
currentPatch[patchY,
patchX] = comparePatch[patchY,
patchX]
truePatch = imgWithBorder[int(currY -
window):int(currY +
window + 1),
int(currX -
window):int(currX +
window + 1)]
ret, divideWith = cv.threshold(np.float32(truePatch),
2, 1, cv.THRESH_BINARY)
meanPatch = meanPatch + truePatch
divideWithCoeffs = divideWithCoeffs + divideWith
weight = np.zeros(comparePatch.shape, np.float32)
for patchX in range(patchWidth):
for patchY in range(patchHeight):
val1 = currentPatch[patchY, patchX]
val1 = val1.astype(np.int32)
val2 = comparePatch[patchY, patchX]
val2 = val2.astype(np.int32)
test = pow(val1 - val2, 2)
test = math.exp(-test / h2)
weight[patchY, patchX] = test
val = (1 / pow(sigma, 2))
weight = val * weight
# weight = weight.reshape((-1, 1))
weights.append(weight)
sumWeights = sumWeights + weight
patches.append(comparePatch)
firstSum = 0
secondSum = 0
meanPatch = meanPatch / divideWithCoeffs
# meanPatch = meanPatch.reshape((-1, 1))
mat = la.inv(sumWeights * covariances[currClass] + np.identity(n))
for i in range(len(weights)):
wp = (weights[i] * patches[i])
ws = wp / sumWeights
firstSum = firstSum + ws
firstTerm = (weights[i] / sumWeights)
thirdTerm = meanPatch - patches[i]
secondSum = secondSum + firstTerm * mat * thirdTerm
newPatch = firstSum + secondSum
currentPatch = resultImg[int(currY - window):int(currY + window +
1),
int(currX - window):int(currX + window +
1)]
newPatch = newPatch + currentPatch
resultImg[int(currY - window):int(currY + window + 1),
int(currX - window):int(currX + window + 1)] = newPatch
print(x)
resultImg = util.normalize(resultImg.copy(), 255)
resultImg = np.uint8(resultImg)
return resultImg
dirName = "Netural_Images"
# Read FaceImages
images = readImages(dirName)
# Size of FaceImages, 为了让后续生成的一系列row vector通过reshape变回图像的（193,162,3）的np.array
sz = images[0].shape
# print('shape of sz is', sz)
# Create original faceimages matrix for PCA, each faceimage is a row vector
matrix_faces = createDataMatrix(images)
matrix_faces_T = matrix_faces.T
print('Shape of matrix_faces is ', np.shape(matrix_faces))
# covar, mean_1 = cv2.calcCovarMatrix(matrix_faces, mean=None, flags=cv2.COVAR_ROWS|cv2.COVAR_SCRAMBLED)
covar, mean = cv2.calcCovarMatrix(matrix_faces,
mean=None,
flags=cv2.COVAR_SCALE | cv2.COVAR_ROWS
| cv2.COVAR_SCRAMBLED)
# mean_x is same as mean_1, cv2.COVAR_SCALE 相当于1/M, because the default is 1
print("shape of mean is ", np.shape(mean))
print("shape of covar is ", np.shape(covar))
print('covar is', covar)
eVal, eVec = cv2.eigen(covar, True)[1:]
# 对eVec进行一系列操作，（ui）T * （A）T，再进行normalization，因为OpenCV都是row vector运算，所以跟论文中相当于都要进行转置
eVec = cv2.gemm(eVec, matrix_faces - mean_x, 1, None, 0)
eVec = np.apply_along_axis(lambda n: cv2.normalize(n, n).flat, 1, eVec)
# print("shape of eVal is ", np.shape(eVal))
# # print(eVal)
# # mean_SE = pd.DataFrame.from_dict(mean_SE, orient='index', columns=['values'])
def findSegments():
# load training radiographs
images = rg.readRadiographs(trainingPersonIds)
if debugFB: print 'DB: Training radiographs loaded'
for personToFitId in personToFitIds:
# load radiograph to determine segments for
imageToFit = rg.readRadioGraph(personToFitId)
if debugFB:
print 'DB: Radiograph to fit (#' + str(personToFitId +
1) + ') loaded'
contourImage = imageToFit.copy()
segmentsImage = np.zeros_like(np.array(imageToFit))
if autoInitPoints:
init_points = ip.getModelPointsAutoWhole(personToFitId)
for i in range(toothIds.shape[0]):
toothId = toothIds[i]
# Read data (images and landmarks)
landmarks = lm.readLandmarksOfTooth(toothId, trainingPersonIds)
if debugFB:
print ' DB: Landmarks loaded for tooth #' + str(toothId + 1)
# Initialization of mean vector (xStriped), covariance matrix, x-vector, x-striped-vector (mean), eigenvectors (P) and eigenvalues.
processedLandmarks = procrustes.procrustesMatrix(landmarks, 100)
if debugFB:
print ' DB: Procrustes ready for tooth #' + str(toothId + 1)
pcMean, pcEigv = cv2.PCACompute(
np.transpose(stackPoints(processedLandmarks)))
if debugFB: print ' DB: PCA ready for tooth #' + str(toothId + 1)
xStacked = xStriped = np.transpose(pcMean)
covar, _ = cv2.calcCovarMatrix(
stackPoints(processedLandmarks), cv2.cv.CV_COVAR_SCRAMBLED
| cv2.cv.CV_COVAR_SCALE | cv2.cv.CV_COVAR_COLS)
eigval = np.sort(np.linalg.eigvals(covar), kind='mergesort')[::-1]
# Number of modes
coverage = 0
nbModes = 0
eigval_total = np.sum(eigval)
for value in eigval:
coverage += value / eigval_total
nbModes += 1
if coverage >= 0.99:
break
P = np.transpose(pcEigv[:nbModes]) # normalized
eigval = eigval[:nbModes]
# Initialization of the initial points
if autoInitPoints: X = init_points[:, toothId, :]
else: X = ip.getModelPointsManually(personToFitId, toothId)
# Draw the initial points
initialImage = imageToFit.copy()
cv2.polylines(initialImage, np.int32([X]), True, 255, thickness=2)
#showScaled(initialImage, windowscale, 'initial', False)
# Initialize the model
directions = profile.getDirections(landmarks)
model = profile.getModel(images, landmarks, directions, nModel)
## Protocol 1: step 1 (initialize shape parameters)
b = np.zeros((nbModes, 1))
prev_b = b
stop = False
it = 1
while (not stop):
# Protocol 2: step 1 (examine region around each point to find best nearby match)
Y = profile.getNewModelPoints(imageToFit, X, model, nSample)
# Protocol 2: step 3 = protocol 1
## Protocol 1: step 2 (generate model point positions)
xStacked = xStriped + np.dot(P, b)
## Protocol 1: step 3 & 4 (project Y into the model coordinate frame)
y, translation = procrustes.procrustesTranslateMatrixForPerson(
Y)
scale, rotation = procrustes.alignShapes(
unstackPointsForPerson(xStacked), y)
translation = -translation
y = procrustes.rotateMatrixForPerson(y, -rotation)
y = procrustes.scaleMatrixForPerson(y, 1 / scale)
## Protocol 1: step 5 --> NOT NEEDED??
#yStacked = stackPointsForPerson(y)
#yStacked = yStacked/np.dot(np.transpose(yStacked), xStriped)
#y = unstackPointsForPerson(yStacked)
## Protocol 1: step 6 (update model parameters)
b = np.dot(np.transpose(P),
(stackPointsForPerson(y) - xStriped))
# Protocol 2: step 3 (apply constraints to b)
#mahalonobis = np.sqrt(np.sum(b**2)/np.sum(eigval))
#if mahalonobis > 3.0:
# b = b*(3.0/mahalonobis)
for i in range(b.shape[0]):
if np.abs(b[i, 0]) > 3 * np.sqrt(eigval[i]):
b[i, 0] = np.sign(b[i, 0]) * 3 * np.sqrt(eigval[i])
# Calculate difference with previous result
# and stop iterating after a certain threshold
differences = prev_b - b
prev_b = b
stop = True
for diff in differences:
if np.abs(diff) > 0.01:
stop = False
it += 1
if debugFB:
print ' DB: Tooth #' + str(
toothId + 1) + ' finished in ' + str(it) + ' iterations.'
# Draw the model on the radiograph
x = unstackPointsForPerson(xStriped + np.dot(P, b))
X = procrustes.rotateMatrixForPerson(x, rotation)
X = procrustes.scaleMatrixForPerson(X, scale)
X = procrustes.translateMatrixForPerson(X, translation)
cv2.polylines(contourImage, np.int32([X]), True, 255, thickness=2)
#showScaled(contourImage, windowscale, 'contours', True)
cv2.fillPoly(segmentsImage, np.int32([[X]]), 128)
#showScaled(segmentsImage, windowscale, 'segments', True)
#cv2.imwrite('C:/Users/samue_000/Desktop/' + str(personToFitId+1) + 'i.jpg', initialImage)
#cv2.imwrite('C:/Users/samue_000/Desktop/' + str(personToFitId+1) + 'c.jpg', contourImage)
#cv2.imwrite('C:/Users/samue_000/Desktop/' + str(personToFitId+1) + 's.jpg', segmentsImage)
showScaled(contourImage, windowscale, 'contours', True)
print 'DB: Radiograph #' + str(personToFitId + 1) + ' is segmented.'
def check_building(img, H):
h, w, c = img.shape
# buildingflag = np.zeros((w,1))
buildingflag = np.array([0 for i in range(w)])
for x in range(w - 1):
if abs(H[x] - H[x + 1]) > h / 4:
if H[x] < H[x + 1]:
buildingflag[x] = 1
else:
buildingflag[x + 1] = 1
if sum(buildingflag) < 1:
return H
total_sample = sum(H)
num_building = sum(H[buildingflag == 1])
buildingsample = np.zeros((num_building, 3))
skysample = np.zeros((total_sample - num_building, 3))
skyidx = 0
buildingidx = 0
for x in range(w):
if buildingflag[x] == 0:
for y in range(H[x]):
skysample[skyidx, 0] = img[y, x, 0]
skysample[skyidx, 1] = img[y, x, 1]
skysample[skyidx, 2] = img[y, x, 2]
skyidx = skyidx + 1
else:
for y in range(H[x]):
buildingsample[buildingidx, 0] = img[y, x, 0]
buildingsample[buildingidx, 1] = img[y, x, 1]
buildingsample[buildingidx, 2] = img[y, x, 2]
buildingidx = buildingidx + 1
skycov, skymean = cv2.calcCovarMatrix(skysample,
cv2.COVAR_ROWS | cv2.COVAR_NORMAL)
buildingcov, buildingmean = cv2.calcCovarMatrix(
buildingsample, cv2.COVAR_ROWS | cv2.COVAR_NORMAL)
ret, skycovInv = cv2.invert(skycov)
ret, buildingcovInv = cv2.invert(buildingcov)
for x in range(w):
if buildingflag[x] == 1:
continue
idx = 0
sample = np.zeros((H[x], 3))
for y in range(H[x]):
sample[idx, 0] = img[y, x, 0]
sample[idx, 1] = img[y, x, 1]
sample[idx, 2] = img[y, x, 2]
idx = idx + 1
num_sample = sample.shape[0]
ss = sample - np.tile(skymean, (num_sample, 1))
dsky = np.dot(np.dot(ss, skycovInv), ss.T)
ss = sample - np.tile(buildingmean, (num_sample, 1))
dbuilding = np.matrix(ss) * np.matrix(buildingcovInv) * np.matrix(ss).T
dsky = np.diag(dsky)
dbuilding = np.diag(dbuilding)
num_sky = sum(dsky < dbuilding)
if num_sky * 2 < num_sample:
buildingflag[x] = 1
for x in range(w):
if buildingflag[x] == 1:
H[x] = 0
return (H)
def getOrientation(contours, img):
array = contours.flatten()
cv2.calcCovarMatrix(array, cv2.cv.CV_COVAR_SCALE | cv2.cv.CV_COVAR_ROWS)
def fit_quality(self, point_index, model_factors, test_image, test_shape):
model_patch = self.generate_grey(point_index, model_factors)
test_patch = self._get_normal_grey_levels_for_single_point_single_image(test_image, test_shape, point_index)
return cv2.Mahalanobis(model_patch, test_patch,
np.linalg.pinv(cv2.calcCovarMatrix(np.concatenate((model_patch, test_patch)))))
def pcaBuiltIn(landmarks):
mean, vec = cv.PCACompute(landmarks, None)
covar, _ = cv.calcCovarMatrix(
landmarks,
cv.cv.CV_COVAR_SCRAMBLED | cv.cv.CV_COVAR_SCALE | cv.cv.CV_COVAR_COLS)
return covar
