Python numpy.polyfit() Examples
The following are 30
code examples of numpy.polyfit().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
numpy
, or try the search function
.
.
Example #1
| Source File: num.py From pwtools with BSD 3-Clause "New" or "Revised" License | 6 votes |
|
def vander(points, deg):
"""N-dim Vandermonde matrix for data `points` and a polynomial of degree
`deg`.
Parameters
----------
points : see polyfit()
deg : int
Degree of the poly (e.g. 3 for cubic).
Returns
-------
vander : 2d array (npoints, (deg+1)**ndim)
"""
powers = poly_powers(points.shape[1], deg)
# low memory version, slower
##npoints = points.shape[0]
##vand = np.empty((npoints, (deg+1)**ndim), dtype=float)
##for ipoint in range(npoints):
## vand[ipoint,:] = (points[ipoint]**powers).prod(axis=1)
tmp = (points[...,None] ** np.swapaxes(powers, 0, 1)[None,...])
return tmp.prod(axis=1)
Example #2
| Source File: linemin.py From pyqmc with MIT License | 6 votes |
|
def stable_fit(xfit, yfit):
p = np.polyfit(xfit, yfit, 2)
steprange = np.max(xfit)
minstep = np.min(xfit)
est_min = -p[1] / (2 * p[0])
if est_min > steprange and p[0] > 0: # minimum past the search radius
est_min = steprange
if est_min < minstep and p[0] > 0: # mimimum behind the search radius
est_min = minstep
if p[0] < 0:
plin = np.polyfit(xfit, yfit, 1)
if plin[0] < 0:
est_min = steprange
if plin[0] > 0:
est_min = minstep
# print("estimated minimum adjusted", est_min, flush=True)
return est_min
Example #3
| Source File: classifier.py From tempo-cnn with GNU Affero General Public License v3.0 | 6 votes |
|
def quad_interpol_argmax(y, x=None):
"""
Find argmax for quadratic interpolation around argmax of y.
:param x: x corresponding to (a) peak in y, if not set, ``np.argmax(y)`` is used
:param y: array
:return: float (index) of interpolated max, strength
"""
if x is None:
x = np.argmax(y)
if x == 0 or x == y.shape[0] - 1:
return x, y[x]
z = np.polyfit([x - 1, x, x + 1], [y[x - 1], y[x], y[x + 1]], 2)
# find (float) x value for max
argmax = -z[1] / (2. * z[0])
height = z[2] - (z[1] ** 2.) / (4. * z[0])
return argmax, height
Example #4
| Source File: xas_process.py From MPContribs with MIT License | 6 votes |
|
def remove_linear_BG_XAS_preedge(
xmcd_data, scanparams, process_parameters=None, process_number=-1
):
"""Should remove a linear bg based on the preedge average"""
preedge_spectrum = get_preedge_spectrum(process_parameters, xmcd_data)
preedge_poly = np.poly1d(
np.polyfit(preedge_spectrum["Energy"], preedge_spectrum["XAS"], 1)
)
xas_bg = preedge_poly(xmcd_data["Energy"])
for xas in ["XAS+", "XAS-", "XAS"]:
xmcd_data[xas] -= xas_bg
return (xmcd_data, {"xas_bg_poly_coeffs": " ".join(map(str, preedge_poly.coeffs))})
Example #5
| Source File: temperature.py From petrophysics with MIT License | 6 votes |
|
def horner(circulation_time, times, temp):
'''
horner_bht_temp (circulation_time, times, temp)
*Input parameters:
- circulation_time - hours from last circulation;
- times - total time since circulation stopped at 1st Run, 2nd Run and so on ...
- temp - a list o temperatures coresponding to 1st Run, 2nd Run and so on ...
*Returns:
- horner_temp - formation temperature estimated by Horner method (thermometer readings
from different runs)
*Exemple of usage:
horner(6, (7.0,11.5,19.5), (100,105,108))
where:
circulation_time = 6 # time since circulation stopped (hours)
times = (7.0,11.5,19.5) # total time since circulation stopped at 1st, 2nd, 3rd RUN (hours)
temp=(100,105,108) # temperatures recorded at 1st, 2nd, 3rd RUN (Celsius degrees)
'''
horner_time = np.array(times) / (circulation_time + np.array(times))
slope,intercept = np.polyfit (np.log(horner_time), temp, 1)
horner_temp=round(slope*np.log(1) +intercept,2)
return horner_temp
Example #6
| Source File: test_regression.py From recruit with Apache License 2.0 | 6 votes |
|
def test_polyfit_build(self):
# Ticket #628
ref = [-1.06123820e-06, 5.70886914e-04, -1.13822012e-01,
9.95368241e+00, -3.14526520e+02]
x = [90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 129,
130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157,
158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
170, 171, 172, 173, 174, 175, 176]
y = [9.0, 3.0, 7.0, 4.0, 4.0, 8.0, 6.0, 11.0, 9.0, 8.0, 11.0, 5.0,
6.0, 5.0, 9.0, 8.0, 6.0, 10.0, 6.0, 10.0, 7.0, 6.0, 6.0, 6.0,
13.0, 4.0, 9.0, 11.0, 4.0, 5.0, 8.0, 5.0, 7.0, 7.0, 6.0, 12.0,
7.0, 7.0, 9.0, 4.0, 12.0, 6.0, 6.0, 4.0, 3.0, 9.0, 8.0, 8.0,
6.0, 7.0, 9.0, 10.0, 6.0, 8.0, 4.0, 7.0, 7.0, 10.0, 8.0, 8.0,
6.0, 3.0, 8.0, 4.0, 5.0, 7.0, 8.0, 6.0, 6.0, 4.0, 12.0, 9.0,
8.0, 8.0, 8.0, 6.0, 7.0, 4.0, 4.0, 5.0, 7.0]
tested = np.polyfit(x, y, 4)
assert_array_almost_equal(ref, tested)
Example #7
| Source File: test_mu_law.py From tensorflow-wavenet with MIT License | 6 votes |
|
def testEncodeDecodeShift(self):
x = np.linspace(-1, 1, 1000).astype(np.float32)
with self.test_session() as sess:
encoded = mu_law_encode(x, QUANT_LEVELS)
decoded = mu_law_decode(encoded, QUANT_LEVELS)
roundtripped = sess.run(decoded)
# Detect non-unity scaling and non-zero shift in the roundtripped
# signal by asserting that slope = 1 and y-intercept = 0 of line fit to
# roundtripped vs x values.
coeffs = np.polyfit(x, roundtripped, 1)
slope = coeffs[0]
y_intercept = coeffs[1]
EPSILON = 1e-4
self.assertNear(slope, 1.0, EPSILON)
self.assertNear(y_intercept, 0.0, EPSILON)
Example #8
| Source File: test_regression.py From lambda-packs with MIT License | 6 votes |
|
def test_polyfit_build(self):
# Ticket #628
ref = [-1.06123820e-06, 5.70886914e-04, -1.13822012e-01,
9.95368241e+00, -3.14526520e+02]
x = [90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 129,
130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157,
158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
170, 171, 172, 173, 174, 175, 176]
y = [9.0, 3.0, 7.0, 4.0, 4.0, 8.0, 6.0, 11.0, 9.0, 8.0, 11.0, 5.0,
6.0, 5.0, 9.0, 8.0, 6.0, 10.0, 6.0, 10.0, 7.0, 6.0, 6.0, 6.0,
13.0, 4.0, 9.0, 11.0, 4.0, 5.0, 8.0, 5.0, 7.0, 7.0, 6.0, 12.0,
7.0, 7.0, 9.0, 4.0, 12.0, 6.0, 6.0, 4.0, 3.0, 9.0, 8.0, 8.0,
6.0, 7.0, 9.0, 10.0, 6.0, 8.0, 4.0, 7.0, 7.0, 10.0, 8.0, 8.0,
6.0, 3.0, 8.0, 4.0, 5.0, 7.0, 8.0, 6.0, 6.0, 4.0, 12.0, 9.0,
8.0, 8.0, 8.0, 6.0, 7.0, 4.0, 4.0, 5.0, 7.0]
tested = np.polyfit(x, y, 4)
assert_array_almost_equal(ref, tested)
Example #9
| Source File: test_regression.py From auto-alt-text-lambda-api with MIT License | 6 votes |
|
def test_polyfit_build(self):
# Ticket #628
ref = [-1.06123820e-06, 5.70886914e-04, -1.13822012e-01,
9.95368241e+00, -3.14526520e+02]
x = [90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 129,
130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157,
158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
170, 171, 172, 173, 174, 175, 176]
y = [9.0, 3.0, 7.0, 4.0, 4.0, 8.0, 6.0, 11.0, 9.0, 8.0, 11.0, 5.0,
6.0, 5.0, 9.0, 8.0, 6.0, 10.0, 6.0, 10.0, 7.0, 6.0, 6.0, 6.0,
13.0, 4.0, 9.0, 11.0, 4.0, 5.0, 8.0, 5.0, 7.0, 7.0, 6.0, 12.0,
7.0, 7.0, 9.0, 4.0, 12.0, 6.0, 6.0, 4.0, 3.0, 9.0, 8.0, 8.0,
6.0, 7.0, 9.0, 10.0, 6.0, 8.0, 4.0, 7.0, 7.0, 10.0, 8.0, 8.0,
6.0, 3.0, 8.0, 4.0, 5.0, 7.0, 8.0, 6.0, 6.0, 4.0, 12.0, 9.0,
8.0, 8.0, 8.0, 6.0, 7.0, 4.0, 4.0, 5.0, 7.0]
tested = np.polyfit(x, y, 4)
assert_array_almost_equal(ref, tested)
Example #10
| Source File: xrft.py From xrft with MIT License | 6 votes |
|
def fit_loglog(x, y):
"""
Fit a line to isotropic spectra in log-log space
Parameters
----------
x : `numpy.array`
Coordinate of the data
y : `numpy.array`
data
Returns
-------
y_fit : `numpy.array`
The linear fit
a : float64
Slope of the fit
b : float64
Intercept of the fit
"""
# fig log vs log
p = np.polyfit(np.log2(x), np.log2(y), 1)
y_fit = 2**(np.log2(x)*p[0] + p[1])
return y_fit, p[0], p[1]
Example #11
| Source File: test_regression.py From vnpy_crypto with MIT License | 6 votes |
|
def test_polyfit_build(self):
# Ticket #628
ref = [-1.06123820e-06, 5.70886914e-04, -1.13822012e-01,
9.95368241e+00, -3.14526520e+02]
x = [90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 129,
130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157,
158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
170, 171, 172, 173, 174, 175, 176]
y = [9.0, 3.0, 7.0, 4.0, 4.0, 8.0, 6.0, 11.0, 9.0, 8.0, 11.0, 5.0,
6.0, 5.0, 9.0, 8.0, 6.0, 10.0, 6.0, 10.0, 7.0, 6.0, 6.0, 6.0,
13.0, 4.0, 9.0, 11.0, 4.0, 5.0, 8.0, 5.0, 7.0, 7.0, 6.0, 12.0,
7.0, 7.0, 9.0, 4.0, 12.0, 6.0, 6.0, 4.0, 3.0, 9.0, 8.0, 8.0,
6.0, 7.0, 9.0, 10.0, 6.0, 8.0, 4.0, 7.0, 7.0, 10.0, 8.0, 8.0,
6.0, 3.0, 8.0, 4.0, 5.0, 7.0, 8.0, 6.0, 6.0, 4.0, 12.0, 9.0,
8.0, 8.0, 8.0, 6.0, 7.0, 4.0, 4.0, 5.0, 7.0]
tested = np.polyfit(x, y, 4)
assert_array_almost_equal(ref, tested)
Example #12
| Source File: test_regression.py From Computable with MIT License | 6 votes |
|
def test_polyfit_build(self):
"""Ticket #628"""
ref = [-1.06123820e-06, 5.70886914e-04, -1.13822012e-01,
9.95368241e+00, -3.14526520e+02]
x = [90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 129,
130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157,
158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
170, 171, 172, 173, 174, 175, 176]
y = [9.0, 3.0, 7.0, 4.0, 4.0, 8.0, 6.0, 11.0, 9.0, 8.0, 11.0, 5.0,
6.0, 5.0, 9.0, 8.0, 6.0, 10.0, 6.0, 10.0, 7.0, 6.0, 6.0, 6.0,
13.0, 4.0, 9.0, 11.0, 4.0, 5.0, 8.0, 5.0, 7.0, 7.0, 6.0, 12.0,
7.0, 7.0, 9.0, 4.0, 12.0, 6.0, 6.0, 4.0, 3.0, 9.0, 8.0, 8.0,
6.0, 7.0, 9.0, 10.0, 6.0, 8.0, 4.0, 7.0, 7.0, 10.0, 8.0, 8.0,
6.0, 3.0, 8.0, 4.0, 5.0, 7.0, 8.0, 6.0, 6.0, 4.0, 12.0, 9.0,
8.0, 8.0, 8.0, 6.0, 7.0, 4.0, 4.0, 5.0, 7.0]
tested = np.polyfit(x, y, 4)
assert_array_almost_equal(ref, tested)
Example #13
| Source File: test_scaling.py From findiff with MIT License | 6 votes |
|
def fit_1d(self, acc):
nx_list = 10 ** np.linspace(1.75, 2., 10)
Lx = np.pi
log_err_list = []
log_dx_list = []
for nx in nx_list:
x = np.linspace(0., Lx, nx)
dx = x[1] - x[0]
f = np.sin(x)
d_dx = FinDiff(0, dx)
fx = d_dx(f, acc=acc)
fxe = np.cos(x)
err = np.max(np.abs(fxe - fx))
log_dx_list.append(log(dx))
log_err_list.append(log(err))
fit = np.polyfit(log_dx_list, log_err_list, deg=1)
return fit[0]
Example #14
| Source File: test_scaling.py From findiff with MIT License | 6 votes |
|
def fit_2d(self, acc):
nx_list = [10, 30, 100, 300]
ny_list = [10, 30, 100, 300]
Lx, Ly = 3, 3
log_err_list = []
log_dx_list = []
for nx, ny in zip(nx_list, ny_list):
x = np.linspace(0, Lx, nx)
y = np.linspace(0, Ly, ny)
dx, dy = x[1] - x[0], y[1] - y[0]
X, Y = np.meshgrid(x, y, indexing='ij')
f = np.sin(X) * np.sin(Y)
d_dx = FinDiff(0, dx)
fx = d_dx(f, acc=acc)
fxe = np.cos(X) * np.sin(Y)
err = np.max(np.abs(fxe - fx))
log_dx_list.append(log(dx))
log_err_list.append(log(err))
fit = np.polyfit(log_dx_list, log_err_list, deg=1)
return fit[0]
Example #15
| Source File: integrator.py From physical_validation with GNU Lesser General Public License v2.1 | 6 votes |
|
def calculate_rmsd(data, time=None, slope=False):
assert isinstance(data, np.ndarray) and data.ndim == 1
assert time is None or isinstance(time, np.ndarray) and time.ndim == 1
avg = data.mean()
if time is None:
time = np.arange(data.size)
fit = np.polyfit(time, data, 1)
def f(x):
return fit[0] * x + fit[1]
if slope:
rmsd = 0
for t, d in zip(time, data):
rmsd += (d - f(t)) ** 2
rmsd = np.sqrt(rmsd / data.size)
else:
rmsd = data.std()
return avg, rmsd, fit[0]
Example #16
| Source File: test_regression.py From Mastering-Elasticsearch-7.0 with MIT License | 6 votes |
|
def test_polyfit_build(self):
# Ticket #628
ref = [-1.06123820e-06, 5.70886914e-04, -1.13822012e-01,
9.95368241e+00, -3.14526520e+02]
x = [90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 129,
130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141,
146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157,
158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169,
170, 171, 172, 173, 174, 175, 176]
y = [9.0, 3.0, 7.0, 4.0, 4.0, 8.0, 6.0, 11.0, 9.0, 8.0, 11.0, 5.0,
6.0, 5.0, 9.0, 8.0, 6.0, 10.0, 6.0, 10.0, 7.0, 6.0, 6.0, 6.0,
13.0, 4.0, 9.0, 11.0, 4.0, 5.0, 8.0, 5.0, 7.0, 7.0, 6.0, 12.0,
7.0, 7.0, 9.0, 4.0, 12.0, 6.0, 6.0, 4.0, 3.0, 9.0, 8.0, 8.0,
6.0, 7.0, 9.0, 10.0, 6.0, 8.0, 4.0, 7.0, 7.0, 10.0, 8.0, 8.0,
6.0, 3.0, 8.0, 4.0, 5.0, 7.0, 8.0, 6.0, 6.0, 4.0, 12.0, 9.0,
8.0, 8.0, 8.0, 6.0, 7.0, 4.0, 4.0, 5.0, 7.0]
tested = np.polyfit(x, y, 4)
assert_array_almost_equal(ref, tested)
Example #17
| Source File: checkdam.py From hydrology with GNU General Public License v3.0 | 6 votes |
|
def polyfit(x, y, degree):
"""
Wrapper around np.polyfit
:param x: x values
:param y: y values
:param degree: polynomial degree
:return: results, polynomial has coefficients, determination has r-squared
:rtype: dict
"""
results = {}
coeffs = np.polyfit(x, y, degree)
results['polynomial'] = coeffs.tolist()
# r squared
p = np.poly1d(coeffs)
yhat = p(x)
ybar = np.sum(y) / len(y)
ssreg = np.sum((yhat - ybar) ** 2)
sstot = np.sum((y - ybar) ** 2)
results['determination'] = ssreg / sstot
return results
Example #18
| Source File: k_analysis.py From ocelot with GNU General Public License v3.0 | 6 votes |
|
def data_analysis(e_ph, flux, method="least"):
if method == "least":
coeffs = np.polyfit(x=e_ph, y=flux, deg=11)
polynom = np.poly1d(coeffs)
x = np.linspace(e_ph[0], e_ph[-1], num=100)
pd = np.polyder(polynom, m=1)
indx = np.argmax(np.abs(pd(x)))
eph_c = x[indx]
pd2 = np.polyder(polynom, m=2)
p2_roots = np.roots(pd2)
p2_roots = p2_roots[p2_roots[:].imag == 0]
p2_roots = np.real(p2_roots)
Eph_fin = find_nearest(p2_roots,eph_c)
return Eph_fin, polynom
elif method == "new method":
pass
#plt.plot(Etotal, total, "ro")
#plt.plot(x, polynom(x))
Example #19
| Source File: snr_test.py From TheCannon with MIT License | 6 votes |
|
def quad_fit(x, y, yerr, name, unit):
""" Fit a qudratic to the SNR to make a lookup error table """
print("performing quad fit")
qfit = np.polyfit(x, y, deg=2, w = 1 / yerr)
print(qfit)
plt.figure()
#plt.scatter(x, y)
plt.errorbar(x, y, yerr=yerr, fmt='.', c='k')
xvals = np.linspace(min(x), max(x), 100)
print(xvals)
yvals = qfit[2] + qfit[1]*xvals + qfit[0]*xvals**2
print(yvals)
plt.plot(xvals, yvals, color='r', lw=2)
plt.xlabel("%s" %snr_label, fontsize=16)
plt.ylabel(r"$\sigma %s \mathrm{(%s)}$" %(name,unit), fontsize=16)
plt.show()
Example #20
| Source File: text_proposal_connector_oriented.py From text-detection-ocr with Apache License 2.0 | 5 votes |
|
def fit_y(self, X, Y, x1, x2):
len(X)!=0
# if X only include one point, the function will get line y=Y[0]
if np.sum(X==X[0])==len(X):
return Y[0], Y[0]
p=np.poly1d(np.polyfit(X, Y, 1))
return p(x1), p(x2)
Example #21
| Source File: comma_ai_lane_detect.py From MachineLearning with Apache License 2.0 | 5 votes |
|
def draw_lines_extrapolate(img, lines, color=[255, 0, 0], thickness=2):
# Assume lines on left and right have opposite signed slopes
left_xs = []
left_ys = []
right_xs = []
right_ys = []
for line in lines:
for x1, y1, x2, y2 in line:
if x2 - x1 == 0: continue; # Infinite slope
slope = float(y2-y1) / float(x2-x1)
if .5 <= abs(slope) < 1.0: # Discard unlikely slopes
if slope > 0:
left_xs.extend([x1, x2])
left_ys.extend([y1, y2])
else:
right_xs.extend([x1, x2])
right_ys.extend([y1, y2])
y1 = img.shape[0] - 120 # Bottom of image
y2 = img.shape[0] / 2 + 10 # Middle of view
y1 = int(y1); y2 = int(y2);
if left_xs and left_ys:
left_fit = np.polyfit(left_xs, left_ys, 1)
x1_left = (y1 - left_fit[1]) / left_fit[0]
x2_left = (y2 - left_fit[1]) / left_fit[0]
x1_left = int(x1_left); x2_left = int(x2_left);
cv2.line(img, (x1_left, y1), (x2_left, y2), color, thickness)
if right_xs and right_ys:
right_fit = np.polyfit(right_xs, right_ys, 1)
x1_right = (y1 - right_fit[1]) / right_fit[0]
x2_right = (y2 - right_fit[1]) / right_fit[0]
x1_right = int(x1_right); x2_right = int(x2_right);
cv2.line(img, (x1_right, y1), (x2_right, y2), color, thickness)
Example #22
| Source File: udacity_lane_detect.py From MachineLearning with Apache License 2.0 | 5 votes |
|
def draw_lines_extrapolate(img, lines, color=[255, 0, 0], thickness=2):
# Assume lines on left and right have opposite signed slopes
left_xs = []
left_ys = []
right_xs = []
right_ys = []
for line in lines:
for x1, y1, x2, y2 in line:
if x2 - x1 == 0: continue; # Infinite slope
slope = float(y2-y1) / float(x2-x1)
if .5 <= abs(slope) < 1.0: # Discard unlikely slopes
if slope > 0:
left_xs.extend([x1, x2])
left_ys.extend([y1, y2])
else:
right_xs.extend([x1, x2])
right_ys.extend([y1, y2])
left_fit = np.polyfit(left_xs, left_ys, 1)
right_fit = np.polyfit(right_xs, right_ys, 1)
y1 = img.shape[0] # Bottom of image
y2 = img.shape[0] / 2+ 50 # Middle of view
x1_left = (y1 - left_fit[1]) / left_fit[0]
x2_left = (y2 - left_fit[1]) / left_fit[0]
x1_right = (y1 - right_fit[1]) / right_fit[0]
x2_right = (y2 - right_fit[1]) / right_fit[0]
y1 = int(y1); y2 = int(y2);
x1_left = int(x1_left); x2_left = int(x2_left);
x1_right = int(x1_right); x2_right = int(x2_right);
cv2.line(img, (x1_left, y1), (x2_left, y2), color, thickness)
cv2.line(img, (x1_right, y1), (x2_right, y2), color, thickness)
Example #23
| Source File: extras.py From Computable with MIT License | 5 votes |
|
def polyfit(x, y, deg, rcond=None, full=False, w=None, cov=False):
"""
Any masked values in x is propagated in y, and vice-versa.
"""
x = asarray(x)
y = asarray(y)
m = getmask(x)
if y.ndim == 1:
m = mask_or(m, getmask(y))
elif y.ndim == 2:
my = getmask(mask_rows(y))
if my is not nomask:
m = mask_or(m, my[:, 0])
else:
raise TypeError("Expected a 1D or 2D array for y!")
if w is not None:
w = asarray(w)
if w.ndim != 1:
raise TypeError("expected a 1-d array for weights")
if w.shape[0] != y.shape[0] :
raise TypeError("expected w and y to have the same length")
m = mask_or(m, getmask(w))
if m is not nomask:
if w is not None:
w = ~m*w
else:
w = ~m
return np.polyfit(x, y, deg, rcond, full, w, cov)
Example #24
| Source File: measures.py From nolds with MIT License | 5 votes |
|
def poly_fit(x, y, degree, fit="RANSAC"):
# check if we can use RANSAC
if fit == "RANSAC":
try:
# ignore ImportWarnings in sklearn
with warnings.catch_warnings():
warnings.simplefilter("ignore", ImportWarning)
import sklearn.linear_model as sklin
import sklearn.preprocessing as skpre
except ImportError:
warnings.warn(
"fitting mode 'RANSAC' requires the package sklearn, using"
+ " 'poly' instead",
RuntimeWarning)
fit = "poly"
if fit == "poly":
return np.polyfit(x, y, degree)
elif fit == "RANSAC":
model = sklin.RANSACRegressor(sklin.LinearRegression(fit_intercept=False))
xdat = np.asarray(x)
if len(xdat.shape) == 1:
# interpret 1d-array as list of len(x) samples instead of
# one sample of length len(x)
xdat = xdat.reshape(-1, 1)
polydat = skpre.PolynomialFeatures(degree).fit_transform(xdat)
try:
model.fit(polydat, y)
coef = model.estimator_.coef_[::-1]
except ValueError:
warnings.warn(
"RANSAC did not reach consensus, "
+ "using numpy's polyfit",
RuntimeWarning)
coef = np.polyfit(x, y, degree)
return coef
else:
raise ValueError("invalid fitting mode ({})".format(fit))
Example #25
| Source File: eventrelated_utils.py From NeuroKit with MIT License | 5 votes |
|
def _eventrelated_rate(epoch, output={}, var="ECG_Rate"):
# Sanitize input
colnames = epoch.columns.values
if len([i for i in colnames if var in i]) == 0:
print(
"NeuroKit warning: *_eventrelated(): input does not"
"have an `" + var + "` column. Will skip all rate-related features."
)
return output
# Get baseline
zero = find_closest(0, epoch.index.values, return_index=True) # Find closest to 0
baseline = epoch[var].iloc[zero]
signal = epoch[var].values[zero + 1 : :]
index = epoch.index.values[zero + 1 : :]
# Max / Min / Mean
output[var + "_Baseline"] = baseline
output[var + "_Max"] = np.max(signal) - baseline
output[var + "_Min"] = np.min(signal) - baseline
output[var + "_Mean"] = np.mean(signal) - baseline
# Time of Max / Min
output[var + "_Max_Time"] = index[np.argmax(signal)]
output[var + "_Min_Time"] = index[np.argmin(signal)]
# Modelling
# These are experimental indices corresponding to parameters of a quadratic model
# Instead of raw values (such as min, max etc.)
coefs = np.polyfit(index, signal - baseline, 2)
output[var + "_Trend_Quadratic"] = coefs[0]
output[var + "_Trend_Linear"] = coefs[1]
output[var + "_Trend_R2"] = fit_r2(
y=signal - baseline, y_predicted=np.polyval(coefs, index), adjusted=False, n_parameters=3
)
return output
Example #26
| Source File: correlation.py From NeuroKit with MIT License | 5 votes |
|
def _cor_plot(x, y):
# Create scatter
plt.plot(x, y, "o")
# Add regresion line
m, b = np.polyfit(x, y, 1)
plt.plot(np.array(x), m * np.array(x) + b)
Example #27
| Source File: fractal_dfa.py From NeuroKit with MIT License | 5 votes |
|
def _fractal_dfa_trends(segments, window, order=1):
x = np.arange(window)
coefs = np.polyfit(x[:window], segments.T, order).T
# TODO: Could this be optimized? Something like np.polyval(x[:window], coefs)
trends = np.array([np.polyval(coefs[j], x) for j in np.arange(len(segments))])
return trends
Example #28
| Source File: text_proposal_connector_oriented.py From ICDAR-2019-SROIE with MIT License | 5 votes |
|
def fit_y(self, X, Y, x1, x2):
len(X) != 0
# if X only include one point, the function will get line y=Y[0]
if np.sum(X == X[0]) == len(X):
return Y[0], Y[0]
p = np.poly1d(np.polyfit(X, Y, 1))
return p(x1), p(x2)
Example #29
| Source File: test_extras.py From Mastering-Elasticsearch-7.0 with MIT License | 5 votes |
|
def test_polyfit(self):
# Tests polyfit
# On ndarrays
x = np.random.rand(10)
y = np.random.rand(20).reshape(-1, 2)
assert_almost_equal(polyfit(x, y, 3), np.polyfit(x, y, 3))
# ON 1D maskedarrays
x = x.view(MaskedArray)
x[0] = masked
y = y.view(MaskedArray)
y[0, 0] = y[-1, -1] = masked
#
(C, R, K, S, D) = polyfit(x, y[:, 0], 3, full=True)
(c, r, k, s, d) = np.polyfit(x[1:], y[1:, 0].compressed(), 3,
full=True)
for (a, a_) in zip((C, R, K, S, D), (c, r, k, s, d)):
assert_almost_equal(a, a_)
#
(C, R, K, S, D) = polyfit(x, y[:, -1], 3, full=True)
(c, r, k, s, d) = np.polyfit(x[1:-1], y[1:-1, -1], 3, full=True)
for (a, a_) in zip((C, R, K, S, D), (c, r, k, s, d)):
assert_almost_equal(a, a_)
#
(C, R, K, S, D) = polyfit(x, y, 3, full=True)
(c, r, k, s, d) = np.polyfit(x[1:-1], y[1:-1,:], 3, full=True)
for (a, a_) in zip((C, R, K, S, D), (c, r, k, s, d)):
assert_almost_equal(a, a_)
#
w = np.random.rand(10) + 1
wo = w.copy()
xs = x[1:-1]
ys = y[1:-1]
ws = w[1:-1]
(C, R, K, S, D) = polyfit(x, y, 3, full=True, w=w)
(c, r, k, s, d) = np.polyfit(xs, ys, 3, full=True, w=ws)
assert_equal(w, wo)
for (a, a_) in zip((C, R, K, S, D), (c, r, k, s, d)):
assert_almost_equal(a, a_)
Example #30
| Source File: test_extras.py From Computable with MIT License | 5 votes |
|
def test_polyfit(self):
"Tests polyfit"
# On ndarrays
x = np.random.rand(10)
y = np.random.rand(20).reshape(-1, 2)
assert_almost_equal(polyfit(x, y, 3), np.polyfit(x, y, 3))
# ON 1D maskedarrays
x = x.view(MaskedArray)
x[0] = masked
y = y.view(MaskedArray)
y[0, 0] = y[-1, -1] = masked
#
(C, R, K, S, D) = polyfit(x, y[:, 0], 3, full=True)
(c, r, k, s, d) = np.polyfit(x[1:], y[1:, 0].compressed(), 3,
full=True)
for (a, a_) in zip((C, R, K, S, D), (c, r, k, s, d)):
assert_almost_equal(a, a_)
#
(C, R, K, S, D) = polyfit(x, y[:, -1], 3, full=True)
(c, r, k, s, d) = np.polyfit(x[1:-1], y[1:-1, -1], 3, full=True)
for (a, a_) in zip((C, R, K, S, D), (c, r, k, s, d)):
assert_almost_equal(a, a_)
#
(C, R, K, S, D) = polyfit(x, y, 3, full=True)
(c, r, k, s, d) = np.polyfit(x[1:-1], y[1:-1,:], 3, full=True)
for (a, a_) in zip((C, R, K, S, D), (c, r, k, s, d)):
assert_almost_equal(a, a_)
#
w = np.random.rand(10) + 1
wo = w.copy()
xs = x[1:-1]
ys = y[1:-1]
ws = w[1:-1]
(C, R, K, S, D) = polyfit(x, y, 3, full=True, w=w)
(c, r, k, s, d) = np.polyfit(xs, ys, 3, full=True, w=ws)
assert_equal(w, wo)
for (a, a_) in zip((C, R, K, S, D), (c, r, k, s, d)):
assert_almost_equal(a, a_)
