def plot_ransac(segment_data_x, segment_data_y):
data = np.column_stack([segment_data_x, segment_data_y])
# fit line using all data
model = LineModelND()
model.estimate(data)
# robustly fit line only using inlier data with RANSAC algorithm
model_robust, inliers = ransac(data,
LineModelND,
min_samples=2,
residual_threshold=1,
max_trials=1000)
outliers = inliers == False
# generate coordinates of estimated models
line_x = np.array([segment_data_x.min(), segment_data_x.max()])
line_y = model.predict_y(line_x)
line_y_robust = model_robust.predict_y(line_x)
print("line_y_robust", line_y_robust)
k = (line_y_robust[1] - line_y_robust[0]) / (line_x[1] - line_x[0])
m = line_y_robust[0] - k * line_x[0]
x0 = (segment_data_y.min() - m) / k
x1 = (segment_data_y.max() - m) / k
line_x_y = np.array([x0, x1])
line_y_robust_y = model_robust.predict_y(line_x_y)
if (distance(line_x[0], line_y_robust[0], line_x[1], line_y_robust[1]) <
distance(line_x_y[0], line_y_robust_y[0], line_x_y[1],
line_y_robust_y[1])):
plt.plot(line_x, line_y_robust, '-b', label='Robust line model')
else:
plt.plot(line_x_y, line_y_robust_y, '-b', label='Robust line model')
def test_deprecated_params_attribute():
model = LineModelND()
model.params = ((0, 0), (1, 1))
x = np.arange(-10, 10)
y = model.predict_y(x)
with expected_warnings(['`_params`']):
assert_equal(model.params, model._params)
def test_line_modelND_estimate():
# generate original data without noise
model0 = LineModelND()
model0.params = (np.array([0,0,0], dtype='float'),
np.array([1,1,1], dtype='float')/np.sqrt(3))
# we scale the unit vector with a factor 10 when generating points on the
# line in order to compensate for the scale of the random noise
data0 = (model0.params[0] +
10 * np.arange(-100,100)[...,np.newaxis] * model0.params[1])
# add gaussian noise to data
random_state = np.random.RandomState(1234)
data = data0 + random_state.normal(size=data0.shape)
# estimate parameters of noisy data
model_est = LineModelND()
model_est.estimate(data)
# test whether estimated parameters are correct
# we use the following geometric property: two aligned vectors have
# a cross-product equal to zero
# test if direction vectors are aligned
assert_almost_equal(np.linalg.norm(np.cross(model0.params[1],
model_est.params[1])), 0, 1)
# test if origins are aligned with the direction
a = model_est.params[0] - model0.params[0]
if np.linalg.norm(a) > 0:
a /= np.linalg.norm(a)
assert_almost_equal(np.linalg.norm(np.cross(model0.params[1], a)), 0, 1)
def test_line_model_nd_residuals():
model = LineModelND()
model.params = (np.array([0, 0, 0]), np.array([0, 0, 1]))
assert_equal(abs(model.residuals(np.array([[0, 0, 0]]))), 0)
assert_equal(abs(model.residuals(np.array([[0, 0, 1]]))), 0)
assert_equal(abs(model.residuals(np.array([[10, 0, 0]]))), 10)
# test params argument in model.rediduals
data = np.array([[10, 0, 0]])
params = (np.array([0, 0, 0]), np.array([2, 0, 0]))
assert_equal(abs(model.residuals(data, params=params)), 30)
def compute_ransac_angles(self,
x_data,
y_data,
n_win=10,
n_trials=100,
verbose=False):
# storage of angles
angs = []
ss = []
startTime = time()
# loop through data
# TODO: Performance edge cases. It would be unfortunate to start our data stream at a corner
for idx in range(len(y_data) - n_win):
# cut window / loop throuh based on n_win
x_curs = x_data[idx:idx + n_win]
y_curs = y_data[idx:idx + n_win]
# setup RANSAC
model_LMND = LineModelND()
points = np.column_stack([x_curs, y_curs])
model_LMND.estimate(points)
# RANSAC
model_RANSAC, _ = ransac(points,
LineModelND,
min_samples=2,
residual_threshold=5,
max_trials=n_trials)
# compute lines
x_range = np.array([x_curs.min(), x_curs.max()])
y_range = model_LMND.predict_y(x_range)
y_range_RANSAC = model_RANSAC.predict_y(x_range)
slope = (y_range_RANSAC[1] - y_range_RANSAC[0]) / \
(x_range[1] - x_range[0])
#print("y_range_RANSAC:", y_range_RANSAC)
# store angle
angs.append(np.arctan(slope))
ss.append(slope)
angs = np.array(angs)
ss = np.array(ss)
angs[angs > 1.5] = angs[angs > 1.5] - np.pi # ??
print('Total time: %fs' % (time() - startTime))
print("angs: ", ss)
return angs, ss
def line_fitting(self, data):
# Please do not modify the header
# fit a line the to arena wall using RANSAC
# return two lists containing slopes and y intercepts of the line
########################
######## YOUR CODE HERE
########################
model = LineModelND()
model.estimate(data)
slope = []
intercept = []
for image in data:
rgb_weights = [0.2989, 0.5870, 0.1140]
gray_image = np.dot(image[..., :3], rgb_weights)
edges = feature.canny(gray_image,
sigma=2,
low_threshold=0.9,
high_threshold=0.999,
mask=None,
use_quantiles=True)
# v = viewer.ImageViewer(edges)
# v.show()
ransac_model, inliers = ransac(np.argwhere(edges),
model_class=measure.LineModelND,
min_samples=2,
residual_threshold=1,
max_trials=15,
stop_sample_num=float('inf'),
stop_residuals_sum=0,
stop_probability=1,
random_state=1,
initial_inliers=None)
outliers = inliers == False
(origin, direction) = np.round(ransac_model.params, 5)
slope_temp = direction[0] / direction[
1] #(finding change in y over change in x)
intercept_temp = origin[0] - slope_temp * origin[
1] #(finding y intercept)
# plt.imshow(gray_image, cmap=plt.cm.gray)
# line_y = np.arange(0, 250)
# line_x = ransac_model.predict_x(line_y)
# p1 = origin
# p2 = direction
# plt.plot(line_y, line_x, color='#ff0000', linewidth=1.5)
# plt.show()
slope.append(slope_temp)
intercept.append(intercept_temp)
# Please do not modify the return type below
return slope, intercept
def test_2D():
np.random.seed(seed=1)
# generate coordinates of line
x = np.arange(-200, 200)
y = 0.2 * x + 20
data = np.column_stack([x, y])
# add gaussian noise to coordinates
noise = np.random.normal(size=data.shape)
data += 0.5 * noise
data[::2] += 5 * noise[::2]
data[::4] += 20 * noise[::4]
# add faulty data
faulty = np.array(30 * [(180., -100)])
faulty += 10 * np.random.normal(size=faulty.shape)
data[:faulty.shape[0]] = faulty
# fit line using all data
model = LineModelND()
model.estimate(data)
# robustly fit line only using inlier data with RANSAC algorithm
model_robust, inliers = ransac(data,
LineModelND,
min_samples=2,
residual_threshold=1,
max_trials=1000)
outliers = inliers == False
# generate coordinates of estimated models
line_x = np.arange(-250, 250)
line_y = model.predict_y(line_x)
line_y_robust = model_robust.predict_y(line_x)
fig, ax = plt.subplots()
ax.plot(data[inliers, 0],
data[inliers, 1],
'.b',
alpha=0.6,
label='Inlier data')
ax.plot(data[outliers, 0],
data[outliers, 1],
'.r',
alpha=0.6,
label='Outlier data')
ax.plot(line_x, line_y, '-k', label='Line model from all data')
ax.plot(line_x, line_y_robust, '-b', label='Robust line model')
ax.legend(loc='lower left')
plt.show()
def test_line_model_nd_invalid_input():
with testing.raises(ValueError):
LineModelND().predict_x(np.zeros(1))
with testing.raises(ValueError):
LineModelND().predict_y(np.zeros(1))
with testing.raises(ValueError):
LineModelND().predict_x(np.zeros(1), np.zeros(1))
with testing.raises(ValueError):
LineModelND().predict_y(np.zeros(1))
with testing.raises(ValueError):
LineModelND().predict_y(np.zeros(1), np.zeros(1))
with testing.raises(ValueError):
LineModelND().estimate(np.empty((1, 3)))
with testing.raises(ValueError):
LineModelND().residuals(np.empty((1, 3)))
data = np.empty((1, 2))
with testing.raises(ValueError):
LineModelND().estimate(data)
def test_line_model_estimate():
# generate original data without noise
model0 = LineModelND()
model0.params = ((0, 0), (1, 1))
x0 = np.arange(-100, 100)
y0 = model0.predict_y(x0)
data = np.column_stack([x0, y0])
# estimate parameters of noisy data
model_est = LineModelND()
model_est.estimate(data)
# test whether estimated parameters almost equal original parameters
x = np.random.rand(100, 2)
assert_almost_equal(model0.predict(x), model_est.predict(x), 1)
def test_line_model_residuals():
model = LineModelND()
model.params = (np.array([0, 0]), np.array([0, 1]))
assert_equal(model.residuals(np.array([[0, 0]])), 0)
assert_equal(model.residuals(np.array([[0, 10]])), 0)
assert_equal(model.residuals(np.array([[10, 0]])), 10)
model.params = (np.array([-2, 0]), np.array([1, 1]) / np.sqrt(2))
assert_equal(model.residuals(np.array([[0, 0]])), np.sqrt(2))
assert_almost_equal(model.residuals(np.array([[-4, 0]])), np.sqrt(2))
def fitCluster(self, hits, plotting=False):
#print (hits)
x = np.array([h[0] for h in hits])
y = np.array([h[1] for h in hits])
data = np.column_stack([x, y])
# fit line using all data
model = LineModelND()
model.estimate(data)
# robustly fit line only using inlier data with RANSAC algorithm
model_robust, inliers = ransac(
data,
LineModelND,
min_samples=self.min_samples_ransac,
residual_threshold=self.residual_threshold_ransac,
max_trials=self.max_trials_ransac)
outliers = inliers == False
line_x = np.arange(0, self.npixx)
line_y = model.predict_y(line_x)
line_y_robust = model_robust.predict_y(line_x)
if plotting:
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.plot(data[inliers, 0],
data[inliers, 1],
'.b',
alpha=0.6,
label='Inlier data')
ax.plot(data[outliers, 0],
data[outliers, 1],
'.r',
alpha=0.6,
label='Outlier data')
ax.plot(line_x, line_y, '-k', label='Line model from all data')
ax.plot(line_x, line_y_robust, '-b', label='Robust line model')
ax.set_ylim(0, self.npixx)
ax.legend(loc='lower left')
plt.show()
extrap_xy = np.column_stack([line_x, line_y]).astype(int)
extrap_xy_robust = np.column_stack([line_x, line_y_robust]).astype(int)
return extrap_xy, extrap_xy_robust
def test_line_model_nd_estimate():
# generate original data without noise
model0 = LineModelND()
model0.params = (np.array([0, 0, 0], dtype='float'),
np.array([1, 1, 1], dtype='float') / np.sqrt(3))
# we scale the unit vector with a factor 10 when generating points on the
# line in order to compensate for the scale of the random noise
data0 = (model0.params[0] +
10 * np.arange(-100, 100)[..., np.newaxis] * model0.params[1])
# add gaussian noise to data
random_state = np.random.RandomState(1234)
data = data0 + random_state.normal(size=data0.shape)
# estimate parameters of noisy data
model_est = LineModelND()
model_est.estimate(data)
# assert_almost_equal(model_est.residuals(data0), np.zeros(len(data)), 1)
# test whether estimated parameters are correct
# we use the following geometric property: two aligned vectors have
# a cross-product equal to zero
# test if direction vectors are aligned
assert_almost_equal(
np.linalg.norm(np.cross(model0.params[1], model_est.params[1])), 0, 1)
# test if origins are aligned with the direction
a = model_est.params[0] - model0.params[0]
if np.linalg.norm(a) > 0:
a /= np.linalg.norm(a)
assert_almost_equal(np.linalg.norm(np.cross(model0.params[1], a)), 0, 1)
def test_line_model_residuals():
model = LineModelND()
model.params = (np.array([0, 0]), np.array([0, 1]))
assert_equal(model.residuals(np.array([[0, 0]])), 0)
assert_equal(model.residuals(np.array([[0, 10]])), 0)
assert_equal(model.residuals(np.array([[10, 0]])), 10)
model.params = (np.array([-2, 0]), np.array([1, 1]) / np.sqrt(2))
assert_equal(model.residuals(np.array([[0, 0]])), np.sqrt(2))
assert_almost_equal(model.residuals(np.array([[-4, 0]])), np.sqrt(2))
def test_line_model_nd_invalid_input():
assert_raises(AssertionError, LineModelND().predict_x, np.zeros(1))
assert_raises(ValueError, LineModelND().predict_x, np.zeros(1), np.zeros(1))
assert_raises(AssertionError, LineModelND().predict_y, np.zeros(1))
assert_raises(ValueError, LineModelND().predict_y, np.zeros(1), np.zeros(1))
assert_raises(ValueError, LineModelND().estimate, np.empty((1, 3)))
assert_raises(AssertionError, LineModelND().residuals, np.empty((1, 3)))
def generate_plottable_points_along_line(model:LineModelND, xmin:int,xmax:int, ymin:int, ymax:int):
"""
Computes points along the specified line model
The visual range is
between xmin and xmax along X axis
and
between ymin and ymax along Y axis
return shape is [[x1,y1],[x2,y2]]
"""
unit_vector=model.params[1]
slope=abs(unit_vector[1]/unit_vector[0])
x_values=None
y_values=None
if (slope > 1):
y_values=np.arange(ymin, ymax,1)
x_values=model.predict_x(y_values)
else:
x_values=np.arange(xmin, xmax,1)
y_values=model.predict_y(x_values)
np_data_points=np.column_stack((x_values,y_values))
return np_data_points
def test_line_model_estimate():
# generate original data without noise
model0 = LineModelND()
model0.params = ((0, 0), (1, 1))
x0 = np.arange(-100, 100)
y0 = model0.predict_y(x0)
data = np.column_stack([x0, y0])
# estimate parameters of noisy data
model_est = LineModelND()
model_est.estimate(data)
# test whether estimated parameters almost equal original parameters
x = np.random.rand(100, 2)
assert_almost_equal(model0.predict(x), model_est.predict(x), 1)
def show_ransac_points_line(points, min_samples=2, residual_threshold=0.1, max_trials=1000, Xrange = 100, displayoutlier= False):
# fit line using all data
model = LineModelND()
if(len(points) > 2):
model.estimate(points)
fig, ax = plt.subplots()
# robustly fit line only using inlier data with RANSAC algorithm
model_robust, inliers = ransac(points, LineModelND, min_samples=min_samples,
residual_threshold=residual_threshold, max_trials=max_trials)
slope , intercept = model_robust.params
outliers = inliers == False
# generate coordinates of estimated models
line_x = np.arange(0, Xrange)
line_y = model.predict_y(line_x)
line_y_robust = model_robust.predict_y(line_x)
#print('Model Fit' , 'yVal = ' , line_y_robust)
#print('Model Fit', 'xVal = ' , line_x)
ax.plot(points[inliers, 0], points[inliers, 1], '.b', alpha=0.6,
label='Inlier data')
if displayoutlier:
ax.plot(points[outliers, 0], points[outliers, 1], '.r', alpha=0.6,
label='Outlier data')
#ax.plot(line_x, line_y, '-r', label='Normal line model')
ax.plot(line_x, line_y_robust, '-g', label='Robust line model')
ax.legend(loc='upper left')
ax.set_xlabel('Time (s)')
ax.set_ylabel('Thickness (um)')
print('Ransac Slope = ', str('%.3e'%((line_y_robust[Xrange - 1] - line_y_robust[0])/ (Xrange)) ))
print('Regression Slope = ', str('%.3e'%((line_y[Xrange - 1] - line_y_robust[0])/ (Xrange)) ))
print('Mean Thickness (After outlier removal) = ', str('%.3f'%(sum(points[inliers, 1])/len(points[inliers, 1]))), 'um')
plt.show()
def ransa(array3):
array5 = []
array4 = []
l = []
data = np.zeros((len(array3), 2))
for g in range(len(array3)):
data[g] = (array3[g][0][0], array3[g][0][1])
l.append(array3[g][0][0])
# fit line using all data
model = LineModelND()
model.estimate(data)
# robustly fit line only using inlier data with RANSAC algorithm
model_robust, inliers = ransac(data, LineModelND, min_samples=2,
residual_threshold=1, max_trials=1000)
outliers = inliers == False
# generate coordinates of estimated models
line_x = l
line_y = model.predict_y(line_x)
line_y_robust = model_robust.predict_y(line_x)
for t in range(len(array3)):
for f in range(len(line_x)):
if abs(array3[t][0][0] - line_x[f]) <= 20 and abs(array3[t][0][1] - line_y_robust[f]) <= 20:
if array3[t] not in array4:
array4.append(array3[t])
if len(array4) >= 9:
for po in range(len(array4)):
if abs(array4[po][0][0] - pixel1) < 200 and abs(array4[po][0][1] - pixel2) < 200:
array5.append(array4[po])
else:
array5 = array4.copy()
return array5
def find_darts_axis(processed_image):
"""
Applies a total least squares estimator to the image that is processed this iteration. The function evaluates the
image data and takes the bounding box into consideration.
For the estimation, the x-axis is vertical to processed_image.image (from top to bottom). The y-axis is horizontal
(from left to right). The represented line follows through the shaft of the dart.
:param processed_image: image that is processed.
:type processed_image: ProcessedImage
:return: An array of y-coordinates. array is as long as the bounding box is high.
:rtype: [int]
"""
if processed_image.has_bounding_box():
x = processed_image.bounding_box.x
y = processed_image.bounding_box.y
w = processed_image.bounding_box.w
h = processed_image.bounding_box.h
segmented_image = processed_image.image[y:y + h, x:x + w]
# find points that are white
data = np.argwhere(segmented_image == 255)
if len(data) < 2:
return None
# estimate least squares
model = LineModelND()
model.estimate(data)
top_y = np.arange(0 - y, h)
try:
return model.predict_y(top_y)
except ValueError: # Can occur when axis is parallel to dartboard
return None
return None
def test_line_model_nd_residuals():
model = LineModelND()
model.params = (np.array([0, 0, 0]), np.array([0, 0, 1]))
assert_equal(abs(model.residuals(np.array([[0, 0, 0]]))), 0)
assert_equal(abs(model.residuals(np.array([[0, 0, 1]]))), 0)
assert_equal(abs(model.residuals(np.array([[10, 0, 0]]))), 10)
# test params argument in model.rediduals
data = np.array([[10, 0, 0]])
params = (np.array([0, 0, 0]), np.array([2, 0, 0]))
assert_equal(abs(model.residuals(data, params=params)), 30)
def test_line_modelND_under_determined():
data = np.empty((1, 3))
with testing.raises(ValueError):
LineModelND().estimate(data)
#print(x,y)
x, y = map(list, zip(*cartesian))
#print(cartesian)
#plt.scatter(y,x)
#plt.show()
# generate coordinates of line
#x = np.arange(-200, 200)
#y = 0.2 * x + 20
data = np.column_stack([x, y])
print(data)
# fit line using all data
model = LineModelND()
model.estimate(data) # estimate random data
# robustly fit line only using inlier data with RANSAC algorithm
model_robust, inliers = ransac(data,
LineModelND,
min_samples=2,
residual_threshold=1,
max_trials=1000)
outliers = inliers == False
# generate coordinates of estimated models
line_x = np.arange(data.min(), data.max())
line_y = model.predict_y(line_x)
line_y_robust = model_robust.predict_y(line_x)
print(line_y_robust)
def test_line_modelND_residuals():
model = LineModelND()
model.params = (np.array([0, 0, 0]), np.array([0, 0, 1]))
assert_equal(abs(model.residuals(np.array([[0, 0, 0]]))), 0)
assert_equal(abs(model.residuals(np.array([[0, 0, 1]]))), 0)
assert_equal(abs(model.residuals(np.array([[10, 0, 0]]))), 10)
y = 0.2 * x + 20
data = np.column_stack([x, y])
# add faulty data
faulty = np.array(30 * [(180., -100)])
faulty += 5 * np.random.normal(size=faulty.shape)
data[:faulty.shape[0]] = faulty
# add gaussian noise to coordinates
noise = np.random.normal(size=data.shape)
data += 0.5 * noise
data[::2] += 5 * noise[::2]
data[::4] += 20 * noise[::4]
# fit line using all data
model = LineModelND()
model.estimate(data)
# robustly fit line only using inlier data with RANSAC algorithm
model_robust, inliers = ransac(data, LineModelND, min_samples=2,
residual_threshold=1, max_trials=1000)
outliers = inliers == False
# generate coordinates of estimated models
line_x = np.arange(-250, 250)
line_y = model.predict_y(line_x)
line_y_robust = model_robust.predict_y(line_x)
fig, ax = plt.subplots()
ax.plot(data[inliers, 0], data[inliers, 1], '.b', alpha=0.6,
label='Inlier data')
def test_line_modelND_predict():
model = LineModelND()
model.params = (np.array([0, 0]), np.array([0.2, 0.98]))
x = np.arange(-10, 10)
y = model.predict_y(x)
assert_almost_equal(x, model.predict_x(y))
# storage of angles
angs = []
startTime = time()
# loop through data
# TODO: Performance edge cases.
for idx in range(len(y_data) - n_win):
# cut window
x_curs = x_data[idx:idx + n_win]
y_curs = y_data[idx:idx + n_win]
# setup RANSAC
model_LMND = LineModelND()
points = np.column_stack([x_curs, y_curs])
model_LMND.estimate(points)
# RANSAC
model_RANSAC, _ = ransac(points,
LineModelND,
min_samples=2,
residual_threshold=5,
max_trials=1000)
# compute lines
x_range = np.array([x_curs.min(), x_curs.max()])
y_range = model_LMND.predict_y(x_range)
y_range_RANSAC = model_RANSAC.predict_y(x_range)
slope = (y_range_RANSAC[1] - y_range_RANSAC[0]) / (x_range[1] - x_range[0])
def test_line_model_predict():
model = LineModelND()
model.params = ((0, 0), (1, 1))
x = np.arange(-10, 10)
y = model.predict_y(x)
assert_almost_equal(x, model.predict_x(y))
x = x.reshape(-1, 1)
y = y.reshape(-1, 1)
data = np.column_stack([x, y])
data1 = data
############# RANSAC Start ##################
inliersArray = np.array([])
print("inliersArray", inliersArray)
dataSize = data.size
print("data size", dataSize)
while dataSize >= 20:
#print('dataSize: ', dataSize)
model = LineModelND()
model.estimate(data)
# robustly fit line only using inlier data with RANSAC algorithm
model_robust, inliers = ransac(data,
LineModelND,
min_samples=2,
residual_threshold=60,
max_trials=100)
outliers = inliers == False
# generate coordinates of estimated models
line_x = np.arange(x.min(), x.max()) #[:, np.newaxis]
line_y = model.predict_y(line_x)
line_y_robust = model_robust.predict_y(line_y)
detectedByRansac = np.column_stack([data[inliers, 0], data[inliers, 1]])
#print('detectedByRansac: ', detectedByRansac)
xx = np.arange(-250, 250) plt.plot(xx, m * xx + c, 'r-'); # <markdowncell> # Scikit-image provides an N-dimensional LineModel object that encapsulates the # above: # <codecell> from skimage.measure import ransac, LineModelND model = LineModelND() model.estimate(data) model.params # <markdowncell> # Instead of ``m`` and ``c``, it parameterizes the line by ``origin`` # and ``direction`` --- much safer when dealing with vertical lines, # e.g.! # <codecell> origin, direction = model.params plt.plot(x, y, 'b.')
def compile_walls(self,
trans_slide,
x_data,
y_data,
n_trials=100,
verbose=False):
# the idea of this function is to compute RANSAC lines on stable regions (walls) as opposed to unstable corners
offset = 1
# pad array to full data length
trans_fill = fill_arr(trans_slide, False, len(x_data), offset=offset)
# pairwise XOR (exclusive or), looking for changes in transition regions
t_idx = [
trans_fill[i] != trans_fill[i + 1]
for i in range(len(trans_fill) - 1)
]
# reassemble these segment points
seg_pts = np.concatenate(([0], np.where(t_idx)[0], [len(x_data) - 1]))
it = iter(seg_pts)
wall_lines = []
# loop through wall segments (two points at a time as a line needs two points)
for p1 in it:
p2 = next(it)
# cut window
x_curs = x_data[p1:p2]
y_curs = y_data[p1:p2]
# ignore small segments
if len(x_curs) < 5:
continue
# setup RANSAC
model_LMND = LineModelND()
points = np.column_stack([x_curs, y_curs])
model_LMND.estimate(points)
# RANSAC
model_RANSAC, _ = ransac(points,
LineModelND,
min_samples=2,
residual_threshold=5,
max_trials=n_trials)
# compute lines
x_range = np.array([x_curs.min(), x_curs.max()])
y_range = model_LMND.predict_y(x_range)
y_range_RANSAC = model_RANSAC.predict_y(x_range)
slope = (y_range_RANSAC[1] - y_range_RANSAC[0]) / (x_range[1] -
x_range[0])
y_range_robust = model_RANSAC.predict_y(x_range)
k = (y_range_robust[1] - y_range_robust[0]) / \
(x_range[1] - x_range[0])
m = y_range_robust[0] - k * x_range[0]
x0 = (y_curs.min() - m) / k
x1 = (y_curs.max() - m) / k
x_range_y = np.array([x0, x1])
y_range_robust_y = model_RANSAC.predict_y(x_range_y)
ww = (y_range_robust_y[1] - y_range_robust_y[0]) / (x_range_y[1] -
x_range_y[0])
if (distance(x_range[0], y_range_robust[0],
x_range[1], y_range_robust[1]) < distance(
x_range_y[0], y_range_robust_y[0], x_range_y[1],
y_range_robust_y[1])):
x_range_r = x_range
y_range_r = y_range_robust
else:
plt.plot(x_range_y,
y_range_robust_y,
'-r',
label='Robust line model')
x_range_r = x_range_y
y_range_r = y_range_robust_y
# what is the absolute distance the wall spans?
x_span = np.abs(x_range_r[1] - x_range_r[0])
y_span = np.abs(y_range_r[1] - y_range_r[0])
if verbose:
plt.scatter(x_data, y_data)
plt.scatter(x_curs, y_curs)
plt.plot(x_range_r, y_range_r, '-r', label='Robust line model')
plt.axis('equal')
plt.show()
print('x_span: %f, y_span: %f' % (x_span, y_span))
# do not record if span is too small (tiny walls can be unstable)
if x_span < 200 and y_span < 200:
continue
# record wall line points (these are arbitrary and are not end points!)
p1 = np.array((x_range_r[0], y_range_r[0]))
p2 = np.array((x_range_r[1], y_range_r[1]))
wall_lines.append((p1, p2))
wall_lines = np.array(wall_lines)
return wall_lines
def test_line_model_nd_under_determined():
assert_raises(ValueError, LineModelND().estimate, np.empty((1, 3)))
def test_line_model_invalid_input():
with testing.raises(ValueError):
LineModelND().estimate(np.empty((1, 3)))
def test_line_model_predict():
model = LineModelND()
model.params = ((0, 0), (1, 1))
x = np.arange(-10, 10)
y = model.predict_y(x)
assert_almost_equal(x, model.predict_x(y))
def test_line_model_under_determined():
data = np.empty((1, 2))
assert_raises(ValueError, LineModelND().estimate, data)
def test_line_model_nd_predict():
model = LineModelND()
model.params = (np.array([0, 0]), np.array([0.2, 0.8]))
x = np.arange(-10, 10)
y = model.predict_y(x)
assert_almost_equal(x, model.predict_x(y))
def test_line_model_invalid_input():
assert_raises(ValueError, LineModelND().estimate, np.empty((1, 3)))
def test_line_modelND_residuals():
model = LineModelND()
model.params = (np.array([0, 0, 0]), np.array([0, 0, 1]))
assert_equal(abs(model.residuals(np.array([[0, 0, 0]]))), 0)
assert_equal(abs(model.residuals(np.array([[0, 0, 1]]))), 0)
assert_equal(abs(model.residuals(np.array([[10, 0, 0]]))), 10)
def iter_ransac(image, sigma=3, no_iter=10, order='col', mxt=2500):
# The plan here is to make the outliers inliers each time or summit
outArray = np.zeros_like(image)
#th = filters.threshold_otsu(inArray)
bw = canny(image, sigma=sigma)
inDex = np.where(bw > 0)
if order == 'col':
inData = np.column_stack([inDex[0], inDex[1]])
if order == 'row':
inData = np.column_stack([inDex[1], inDex[0]])
for i in tqdm(range(0, no_iter)):
# if orient == 'v':
if order == 'col':
#inData = np.column_stack([inDex[0], inDex[1]])
model = LineModelND()
model.estimate(inData)
model_robust, inliers = ransac(inData,
LineModelND,
min_samples=2,
residual_threshold=1,
max_trials=mxt)
outliers = np.invert(inliers)
line_x = inData[:, 0]
line_y = model.predict_y(line_x)
line_y_robust = model_robust.predict_y(line_x)
outArray[line_x, np.int64(np.round(line_y_robust))] = 1
if order == 'row':
# inData = np.column_stack([inDex[1], inDex[0]])
model = LineModelND()
model.estimate(inData)
model_robust, inliers = ransac(inData,
LineModelND,
min_samples=2,
residual_threshold=1,
max_trials=mxt)
outliers = np.invert(inliers)
line_x = inData[:, 0]
line_y = model.predict_y(line_x)
line_y_robust = model_robust.predict_y(line_x)
outArray[np.int64(np.round(line_y_robust)), line_x] = 1
#
inData = inData[:, 0:2][outliers == True]
del model, model_robust, inliers, outliers
return outArray
