Jupyter Demo - Ipynb - Colaboratory

import numpy as np
np.pi
3.141592653589793
help(np)
trunc(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
Return the truncated value of the input, element-wise.
The truncated value of the scalar `x` is the nearest integer ì` which
is closer to zero than `x` is. In short, the fractional part of the
signed number `x` is discarded.
Parameters
----------
x : array_like
Input data.
out : ndarray, None, or tuple of ndarray and None, optional
A location into which the result is stored. If provided, it must have
a shape that the inputs broadcast to. If not provided or None,
a freshly-allocated array is returned. A tuple (possible only as a
keyword argument) must have length equal to the number of outputs.
where : array_like, optional
This condition is broadcast over the input. At locations where the
condition is True, the òut` array will be set to the ufunc result.
Elsewhere, the òut` array will retain its original value.
Note that if an uninitialized òut` array is created via the default
`òut=None``, locations within it where the condition is False will
remain uninitialized.
**kwargs
For other keyword-only arguments, see the
:ref:ùfunc docs <ufuncs.kwargs>`.
Returns
-------
y : ndarray or scalar
The truncated value of each element in `x`.
This is a scalar if `x` is a scalar.
See Also
--------
ceil, floor, rint, fix
Notes
-----
.. versionadded:: 1.3.0
Examples
--------
>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
>>> np.trunc(a)
array([-1., -1., -0., 0., 1., 1., 2.])
typecodes = {'All': '?bhilqpBHILQPefdgFDGSUVOMm', 'AllFloat': 'efdgFDG...
VERSION
1.23.5
FILE
/usr/local/lib/python3.10/dist-packages/numpy/__init__.py
keyboard_arrow_down Robust line model estimation using RANSAC

import matplotlib.pyplot as plt
from scipy import ndimage as ndi
from skimage import feature
import numpy as np
!pip install maskpass -q
!pip install pycountry
Requirement already satisfied: pycountry in /usr/local/lib/python3.10/dist-packages (23.12.11)
im = np.zeros((128, 128))
im[32:-32, 32:-32] = 1
plt.imshow(im, interpolation='nearest', cmap = plt.cm.gray)

plt.show()
im = ndi.rotate(im, 15, mode='constant')

im = ndi.gaussian_filter(im, 4)
# im = im + 0.2 * np.random.random(im.shape)
im += 0.2 * np.random.random(im.shape)
plt.imshow(im, interpolation='nearest', cmap = plt.cm.gray)

plt.show()
edges1 = feature.canny(im)
edges2 = feature.canny(im, sigma = 3)
fig, (ax2, ax3) = plt.subplots(nrows=1, ncols=2, figsize=(8, 3), sharex=True, sharey=True)
ax2.imshow(edges1, cmap = plt.cm.gray)

ax2.axis('off')
ax2.set_title('Canny Filter, $\sigma=1$', fontsize=15)

ax3.axis('off')
fig.tight_layout()
plt.show()
help(feature.canny)
The ``mode`` parameter determines how the array borders are

handled during Gaussian filtering, where ``cval`` is the value when
mode is equal to 'constant'.
cval : float, optional
Value to fill past edges of input if `mode` is 'constant'.
Returns
-------
output : 2D array (image)
The binary edge map.
See also
--------
skimage.sobel
Notes
-----
The steps of the algorithm are as follows:
* Smooth the image using a Gaussian with ``sigma`` width.
* Apply the horizontal and vertical Sobel operators to get the gradients
within the image. The edge strength is the norm of the gradient.
>>> rng = np.random.default_rng()
>>> # Generate noisy image of a square
>>> im = np.zeros((256, 256))
>>> im[64:-64, 64:-64] = 1
>>> im += 0.2 * rng.random(im.shape)
>>> # First trial with the Canny filter, with the default smoothing
>>> edges1 = feature.canny(im)
>>> # Increase the smoothing for better results
>>> edges2 = feature.canny(im, sigma=3)
fig, (ax1, ax2, ax3) = plt.subplots(nrows=1, ncols=3, figsize=(8, 3), sharex=True, sharey=True)
ax1.imshow(im, cmap = plt.cm.gray)

ax1.axis('off')
ax1.set_title('Noisy Image', fontsize=15)

ax2.axis('off')

ax3.axis('off')
fig.tight_layout()
plt.show()
keyboard_arrow_down Robust Fit 3d Points

import numpy as np
from matplotlib import pyplot as plt
from skimage.measure import LineModelND, ransac
rng = np.random.default_rng()
# 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 = rng.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 * rng.normal(size=faulty.shape)
y g ( y p )
data[:faulty.shape[0]] = faulty
# fit line using all data

model = LineModelND()
model.estimate(data)
True
# 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()
output
keyboard_arrow_down Generalize to 3D Points

import numpy as np
from matplotlib import pyplot as plt
from skimage.measure import LineModelND, ransac
# generate coordinates of line

point = np.array([0, 0, 0], dtype='float')
direction = np.array([1, 1, 1], dtype='float') / np.sqrt(3)
xyz = point + 10 * np.arange(-100, 100)[..., np.newaxis] * direction
# add gaussian noise to coordinates

noise = rng.normal(size=xyz.shape)
xyz += 0.5 * noise
xyz[::2] += 20 * noise[::2]
xyz[::4] += 100 * noise[::4]
# robustly fit line only using inlier data with RANSAC algorithm
model_robust, inliers = ransac(xyz, LineModelND, min_samples=2,
residual_threshold=1, max_trials=1000)
outliers = inliers == False
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(xyz[inliers][:, 0], xyz[inliers][:, 1], xyz[inliers][:, 2], c='b',
marker='o', label='Inlier data')
ax.scatter(xyz[outliers][:, 0], xyz[outliers][:, 1], xyz[outliers][:, 2], c='r',
marker='o', label='Outlier data')
ax.legend(loc='lower left')
plt.show()
Start coding or generate with AI.

Jupyter Demo - Ipynb - Colaboratory

Uploaded by

Copyright:

Available Formats

Jupyter Demo - Ipynb - Colaboratory

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Jupyter Demo - Ipynb - Colaboratory

Uploaded by

Copyright:

Available Formats

import numpy as np

Return the truncated value of the input, element-wise.

typecodes = {'All': '?bhilqpBHILQPefdgFDGSUVOMm', 'AllFloat': 'efdgFDG...

keyboard_arrow_down Robust line model estimation using RANSAC

!pip install pycountry

Requirement already satisfied: pycountry in /usr/local/lib/python3.10/dist-packages (23.12.11)

plt.imshow(im, interpolation='nearest', cmap = plt.cm.gray)

im = ndi.rotate(im, 15, mode='constant')

plt.imshow(im, interpolation='nearest', cmap = plt.cm.gray)

ax2.imshow(edges1, cmap = plt.cm.gray)

ax3.imshow(edges2, cmap = plt.cm.gray)

The ``mode`` parameter determines how the array borders are

* Smooth the image using a Gaussian with ``sigma`` width.

ax1.imshow(im, cmap = plt.cm.gray)

ax2.imshow(edges1, cmap = plt.cm.gray)

ax3.imshow(edges2, cmap = plt.cm.gray)

keyboard_arrow_down Robust Fit 3d Points

from skimage.measure import LineModelND, ransac

# generate coordinates of line

# add gaussian noise to coordinates

# add faulty data

# fit line using all data

# generate coordinates of estimated models

keyboard_arrow_down Generalize to 3D Points

# generate coordinates of line

# add gaussian noise to coordinates

Start coding or generate with AI.

You might also like