def _calculatePointResiduals(self, curve, tube_radius = None):
if tube_radius is None:
X = self._X
else:
within_tube_indices = self.calculateCoverageIndices(curve, tube_radius)
X = self._X.take(list(within_tube_indices), axis = 0)
if self._maxSegmentLength is None:
self._maxSegmentLength = self._calculateMaxSegmentLength(curve)
lpc_points = curve['save_xd']
num_lpc_points = len(lpc_points)
tree_lpc_points = KDTree(lpc_points)
residuals = empty(len(X))
residuals_lamb = empty(len(X))
path_length = curve['lamb']
for j, p in enumerate(X):
closest_lpc_point = tree_lpc_points.query(p)
candidate_radius = sqrt(closest_lpc_point[0]**2 + 0.25*self._maxSegmentLength**2)
candidate_segment_ends = tree_lpc_points.query_ball_point(p, candidate_radius)
candidate_segment_ends.sort()
current_min_segment_dist = (closest_lpc_point[0],0)
current_closest_index = closest_lpc_point[1]
last_index = None
for i, index in enumerate(candidate_segment_ends):
if index!=0 and last_index != index - 1:
prv_segment_dist = self._distancePointToLineSegment(lpc_points[index-1], lpc_points[index], p)
if prv_segment_dist[0] < current_min_segment_dist[0]:
current_min_segment_dist = prv_segment_dist
current_closest_index = index - 1
if index != num_lpc_points - 1:
prv_segment_dist = self._distancePointToLineSegment(lpc_points[index], lpc_points[index+1], p)
if prv_segment_dist[0] < current_min_segment_dist[0]:
current_min_segment_dist = prv_segment_dist
current_closest_index = index
last_index = index
residuals[j] = current_min_segment_dist[0]
residuals_lamb[j] = path_length[current_closest_index] + current_min_segment_dist[1]
lamb_order = argsort(residuals_lamb)
return (residuals_lamb[lamb_order], residuals[lamb_order])
def getPathResidualDiags(self, curve):
lpc_points = curve['save_xd']
residuals = self._calculatePrunedPointResiduals(curve)
#strip inf values from arrays with less than k NNs within radius_threshold
point_dist = residuals[0]
point_dist = [point_dist[j][invert(isinf(point_dist[j]))] for j in range(point_dist.shape[0])]
k = self._params['k']
num_NN = map(len, point_dist[:k])
mean_NN = map(mean,point_dist[:k])
std_NN = map(std, point_dist[:k])
#indices will contain entries equal to self._X.shape[0], which are out of bounds
#these are removed with the set symm difference below
indices = residuals[1]
num_tree_pts = set([self._X.shape[0]])
num_lpc_pts = len(lpc_points)
line_seg_mean_NN = zeros(num_lpc_pts - 1)
line_seg_std_NN = zeros(num_lpc_pts - 1)
line_seg_num_NN = zeros(num_lpc_pts - 1)
for i in range(num_lpc_pts - 1):
trial_points = self._X[list(set(indices[i:i+2].ravel()) - num_tree_pts)]
if len(trial_points) != 0:
line_seg_NN_dists = empty(len(trial_points))
j = 0
for p in trial_points:
line_seg_NN_dists[j] = self._distancePointToLineSegment(lpc_points[i], lpc_points[i+1], p)[0]
j = j + 1
line_seg_NN_dists.sort()
line_seg_num_NN[i] = min(len(line_seg_NN_dists), k)
line_seg_mean_NN[i] = mean(line_seg_NN_dists[:k])
line_seg_std_NN[i] = std(line_seg_NN_dists[:k])
else:
line_seg_num_NN[i] = 0
line_seg_mean_NN[i] = 0.0
line_seg_std_NN[i] = 0.0
return {'num_NN': num_NN, 'mean_NN': mean_NN, 'std_NN': std_NN,
'line_seg_num_NN': line_seg_num_NN, 'line_seg_mean_NN': line_seg_mean_NN, 'line_seg_std_NN': line_seg_std_NN}
#coning='gbk'
import sys
import numpy
from numpy.ma.core import arange, dot, empty, zeros
from numpy.core.numeric import ones
from numpy.core.fromnumeric import transpose
from numpy.lib.shape_base import column_stack
from numpy.ma.extras import row_stack
import sys
fr=open('D:\eclipse_workspace\Classify\data\data.txt')
macList=['c0:38:96:25:5b:c3','e0:05:c5:ba:80:40','b0:d5:9d:46:a3:9b','42:a5:89:51:c7:dd']
X=empty((4,60),numpy.int8)
for line in fr:
parts=line.split(',')
try:
poi=macList.index(parts[2])
print('poi',poi)
if poi!='-1':
print('try parts[2]:',parts[2])
lie=int(parts[-1].strip())-1
X[poi,lie] = parts[1]
except :
pass
#print('haha',parts[2])
else:
print('no error')
print("final:",type(list),type(1),type(macList))
print(X)
w=ones((4,1))
