def referenceFunc(point):
"""Reference implementation; point must be in range [-1, 1]
"""
c1 = np.zeros((3, 3))
c1[2, 0] = 1.2
c1[1, 1] = -0.5
c2 = np.zeros((3, 3))
c2[0, 1] = 1.0
x1, x2 = point
return (
chebval2d(x1, x2, c1),
chebval2d(x1, x2, c2),
)
def referenceFunc(point):
"""Reference implementation; point must be in range [-1, 1]
"""
c1 = np.zeros((3, 3))
c1[2, 0] = 1.2
c1[1, 1] = -0.5
c2 = np.zeros((3, 3))
c2[0, 1] = 1.0
x1, x2 = point
return (
chebval2d(x1, x2, c1),
chebval2d(x1, x2, c2),
)
def test_chebval2d(self):
x1, x2, x3 = self.x
y1, y2, y3 = self.y
#test exceptions
assert_raises(ValueError, cheb.chebval2d, x1, x2[:2], self.c2d)
#test values
tgt = y1*y2
res = cheb.chebval2d(x1, x2, self.c2d)
assert_almost_equal(res, tgt)
#test shape
z = np.ones((2, 3))
res = cheb.chebval2d(z, z, self.c2d)
assert_(res.shape == (2, 3))
def test_chebval2d(self):
x1, x2, x3 = self.x
y1, y2, y3 = self.y
#test exceptions
assert_raises(ValueError, cheb.chebval2d, x1, x2[:2], self.c2d)
#test values
tgt = y1*y2
res = cheb.chebval2d(x1, x2, self.c2d)
assert_almost_equal(res, tgt)
#test shape
z = np.ones((2,3))
res = cheb.chebval2d(z, z, self.c2d)
assert_(res.shape == (2,3))
def referenceFunc_f(point):
"""Reference forward implementation; point must be in range [-1, 1]
"""
c1 = np.zeros((4, 4))
c1[2, 0] = -1.1
c1[3, 1] = 1.3
x1, x2 = point
return (chebval2d(x1, x2, c1), )
def cheb_eval(dim, coefs, coords):
if dim == 1:
return chebval(coords[0], coefs)
elif dim == 2:
return chebval2d(coords[0], coords[1], coefs)
elif dim == 3:
return chebval3d(coords[0], coords[1], coords[2], coefs)
else:
raise NotImplementedError('dimension %d not supported' % dim)
def referenceFunc(point):
"""Reference implementation; point must be in range [-1, 1]
"""
c1 = np.zeros((3, 3))
c1[0, 0] = -2
c1[1, 0] = 0.11
c1[0, 1] = -0.2
c1[2, 1] = 0.001
c2 = np.zeros((3, 3))
c2[0, 0] = 5.1
c2[1, 0] = -0.55
c2[0, 1] = 0.13
c2[1, 2] = -0.002
x1, x2 = point
return (
chebval2d(x1, x2, c1),
chebval2d(x1, x2, c2),
)
def referenceFunc(point):
"""Reference implementation; point must be in range [-1, 1]
"""
c1 = np.zeros((3, 3))
c1[0, 0] = -2
c1[1, 0] = 0.11
c1[0, 1] = -0.2
c1[2, 1] = 0.001
c2 = np.zeros((3, 3))
c2[0, 0] = 5.1
c2[1, 0] = -0.55
c2[0, 1] = 0.13
c2[1, 2] = -0.002
x1, x2 = point
return (
chebval2d(x1, x2, c1),
chebval2d(x1, x2, c2),
)
def cheb2d(x, y, ord=[0,0], verbose=False):
coefLen = np.max(ord)+1
coef0 = np.zeros(coefLen)
coef0[ord[0]] = 1
coef1 = np.zeros(coefLen)
coef1[ord[1]] = 1
if verbose:
print ord, coef0, coef1
ch = chebval2d(x, y, c=np.outer(coef0, coef1))
return ch
def referenceFunc_f(point):
"""Reference forward implementation; point must be in range [-1, 1]
"""
c1 = np.zeros((4, 4))
c1[2, 0] = -1.1
c1[3, 1] = 1.3
x1, x2 = point
return (
chebval2d(x1, x2, c1),
)
def cheb2d(x, y, ord=[0, 0], verbose=False):
coefLen = np.max(ord) + 1
coef0 = np.zeros(coefLen)
coef0[ord[0]] = 1
coef1 = np.zeros(coefLen)
coef1[ord[1]] = 1
if verbose:
print ord, coef0, coef1
ch = chebval2d(x, y, c=np.outer(coef0, coef1))
return ch
def cheb2d(x, y, ord=[0, 0], verbose=False):
from numpy.polynomial.chebyshev import chebval2d
coefLen = np.max(ord) + 1
coef0 = np.zeros(coefLen)
coef0[ord[0]] = 1
coef1 = np.zeros(coefLen)
coef1[ord[1]] = 1
if verbose:
print ord, coef0, coef1
ch = chebval2d(x, y, c=np.outer(coef0, coef1))
return ch
def chebReconstruct(orders, locations, coeffs, unusedNumPts):
if len(locations.shape) == 1:
return np.array(cheb.chebval(locations, coeffs))
else:
if locations.shape[1] == 2:
return cheb.chebval2d(locations[:, 0], locations[:, 1], coeffs)
elif locations.shape[1] == 3:
return cheb.chebval3d(locations[:, 0], locations[:, 1],
locations[:, 2], coeffs)
else:
return genericChebVal(locations, coeffs)
def cheb2d(x, y, ord=[0,0], verbose=False):
from numpy.polynomial.chebyshev import chebval2d
coefLen = np.max(ord)+1
coef0 = np.zeros(coefLen)
coef0[ord[0]] = 1
coef1 = np.zeros(coefLen)
coef1[ord[1]] = 1
if verbose:
print ord, coef0, coef1
ch = chebval2d(x, y, c=np.outer(coef0, coef1))
return ch
def test_chebvander2d(self):
# also tests chebval2d for non-square coefficient array
x1, x2, x3 = self.x
c = np.random.random((2, 3))
van = cheb.chebvander2d(x1, x2, [1, 2])
tgt = cheb.chebval2d(x1, x2, c)
res = np.dot(van, c.flat)
assert_almost_equal(res, tgt)
# check shape
van = cheb.chebvander2d([x1], [x2], [1, 2])
assert_(van.shape == (1, 5, 6))
def test_chebvander2d(self) :
# also tests chebval2d for non-square coefficient array
x1, x2, x3 = self.x
c = np.random.random((2, 3))
van = cheb.chebvander2d(x1, x2, [1, 2])
tgt = cheb.chebval2d(x1, x2, c)
res = np.dot(van, c.flat)
assert_almost_equal(res, tgt)
# check shape
van = cheb.chebvander2d([x1], [x2], [1, 2])
assert_(van.shape == (1, 5, 6))
def get_Cheb_logkf(rT,logP):
"""
return log of Chebyshev kf
"""
from numpy.polynomial.chebyshev import chebval2d
import math
log10 = math.log(10.0)
Cheb_logkf = np.zeros(NR_CHEB)
for i,(rTmax,rTmin,logPmax,logPmin,coeffs) in enumerate(ChebyshevReactionConsts):
Tbar = (2*rT-rTmin-rTmax)/(rTmax-rTmin)
Pbar = (2*logP - logPmax -logPmin)/(logPmax - logPmin)
Cheb_logkf[i] = chebval2d(Tbar,Pbar,coeffs)*log10
return Cheb_logkf
def get_Cheb_logkf(rT, logP):
"""
return log of Chebyshev kf
"""
from numpy.polynomial.chebyshev import chebval2d
import math
log10 = math.log(10.0)
Cheb_logkf = np.zeros(NR_CHEB)
for i, (rTmax, rTmin, logPmax, logPmin,
coeffs) in enumerate(ChebyshevReactionConsts):
Tbar = (2 * rT - rTmin - rTmax) / (rTmax - rTmin)
Pbar = (2 * logP - logPmax - logPmin) / (logPmax - logPmin)
Cheb_logkf[i] = chebval2d(Tbar, Pbar, coeffs) * log10
return Cheb_logkf
def fit_2d_polynomial(x, y, z, order):
"""Fit z = f(x,y) as a 2d polynomial function
Returns a function object f.
"""
# I seriously don't know why this isn't a first-level numpy function.
# It required some sleuthing to find all the numpy primitives required, but once
# I found them, it's almost trivial to put them together.
from numpy.polynomial import chebyshev as cheby
A = cheby.chebvander2d(x, y, (order, order))
coeff = np.linalg.lstsq(A, z,
rcond=None)[0].reshape(order + 1, order + 1)
fn = lambda x, y: cheby.chebval2d(x, y, coeff)
return fn
def chebGauss2d(x, y, m=None, s=None, ord=[0, 0], beta=1., verbose=False):
if m is None:
m = [0., 0.]
if s is None:
s = [1., 1.]
# cov = [[s[0], 0], [0, s[1]]]
coefLen = np.max(ord)+1
coef0 = np.zeros(coefLen)
coef0[ord[0]] = 1
coef1 = np.zeros(coefLen)
coef1[ord[1]] = 1
if verbose:
print s, beta, ord, coef0, coef1
ga = psf.singleGaussian2d(x, y, 0, 0, s[0]/beta, s[1]/beta)
ch = chebval2d(x, y, c=np.outer(coef0, coef1))
return ch * ga
def chebGauss2d(x, y, m=None, s=None, ord=[0, 0], beta=1., verbose=False):
if m is None:
m = [0., 0.]
if s is None:
s = [1., 1.]
# cov = [[s[0], 0], [0, s[1]]]
coefLen = np.max(ord) + 1
coef0 = np.zeros(coefLen)
coef0[ord[0]] = 1
coef1 = np.zeros(coefLen)
coef1[ord[1]] = 1
if verbose:
print s, beta, ord, coef0, coef1
ga = psf.singleGaussian2d(x, y, 0, 0, s[0] / beta, s[1] / beta)
ch = chebval2d(x, y, c=np.outer(coef0, coef1))
return ch * ga
def trace_plane_intersection_curve(patches,
hmin,
hmax,
tolchord,
verbose=False):
ori = patches[0].xyz[:, -1, -1]
nor = numpy.cross(patches[0].xyz[:, 0, -1] - ori,
patches[0].xyz[:, -1, 0] - ori)
# find correct border
fc = numpy.array([nor.dot(xc - ori) for xc in patches[1].get_corners()])
for ic in range(4):
if numpy.amax(numpy.absolute(fc[[ic, (ic + 1) % 4]])) < EPS:
if NORMAL_CURVATURE_ONLY:
xyz, uvtmp, t = discretize_curve_on_surface(
uvborders_c[ic],
cht_xyz(patches[1].xyz),
hmin,
hmax,
tolchord,
ta=-1,
tb=1)
uv = numpy.zeros((2, 2, len(t)))
uv[1] = uvtmp
else:
xyz = patches[1].get_border(ic)
c = lch.fcht(xyz).T
xyz, t = discretize_curve(c, hmin, hmax, tolchord, ta=1, tb=-1)
ivar = ic2ivar[ic]
ival = ic2ival[ic]
uv = numpy.zeros((2, 2, len(t)))
uv[1, ivar, :] = (-1)**ival
uv[1, (ivar + 1) % 2] = numpy.sign(1.5 - ic) * t
break
# project onto other plane surface
if verbose: print('\n\n\n')
for ip in range(len(t)):
c = cht_xyz(patches[0].xyz)
cu, cv = lch.diff2(c)
u, v = [0, 0] #uv[0,:,ip]
# Newton
if verbose: print('\n')
for it in range(30):
s = chebval2d(u, v, c)
r = xyz[:, ip] - s
su = chebval2d(u, v, cu)
sv = chebval2d(u, v, cv)
E = su.dot(su)
F = su.dot(sv)
G = sv.dot(sv)
invdet = 1 / (E * G - F**2)
rsu = r.dot(su)
rsv = r.dot(sv)
du = (rsu * G - rsv * F) * invdet
dv = (rsv * E - rsu * F) * invdet
u += du
v += dv
if verbose:
print('it#%d:\tr = %s, duv = %s, (u,v) = (%s, %s)' %
(it, numpy.sqrt(r.dot(r)), numpy.hypot(du, dv), u, v))
if du**2 + dv**2 < EPSuv**2 and r.dot(r) < EPSxyz**2:
uv[0, 0, ip] = u
uv[0, 1, ip] = v
break
#
return Curve_t(patches=patches, xyz=xyz, uv=uv)
def eval(self, x, y):
return np.asarray([
chebval2d(self.scaletodefault(x, self.lower[0], self.upper[0]),
self.scaletodefault(y, self.lower[1], self.upper[1]),
self.c[i]) for i in range(self.dim)
])
tpsubn = np.zeros(nchan_new)
elif info['mode'] == 'single':
info['nsub'] = nperiod
info['file_time'] = time.strftime('%Y-%m-%dT%H:%M:%S', time.gmtime())
d.write_shape([nchan, info['nsub'], nbin, npol])
#
if args.period:
dt = np.array([np.arange(nbin0) * tsamp] * nchan_new)
else:
dt = (np.arange(nbin0) * tsamp - tsamp + np.float64(info['stt_sec']) -
t0) / (t1 - t0) * 2 - 1
for f in np.arange(nchan):
if args.period:
phase = dt / period
else:
phase = nc.chebval2d(dt, np.ones_like(dt), coeff) + dispc / freq_end**2
newphase = np.arange(totalbin)
data = d0.read_chan(f)[0].T
tpdata = np.zeros([npol, totalbin])
for p in np.arange(npol):
tpdata[p] = np.interp(newphase, phase / dphasebin, data[p, :])
if temp_multi > 1:
tpdata = tpdata.reshape(npol, -1, temp_multi).sum(2)
if info['mode'] == 'single':
d.write_chan(tpdata.T, f)
else:
tpdata = np.concatenate(
(tpdata, np.zeros([npol,
(sub_nperiod - sub_nperiod_last) * nbin])),
axis=1).reshape(npol, nsub, sub_nperiod,
nbin).sum(2).reshape(npol, nsub * nbin).T
def discretize_curve_on_surface(cc,
cs,
hmin,
hmax,
tolchord,
ta=-1,
tb=1,
n0=20):
FRACsqr = 4 * tolchord * (2 - tolchord)
cc_t = lch.diff(cc)
cs_u, cs_v = lch.diff2(cs)
cs_uu, cs_uv = lch.diff2(cs_u)
cs_uv, cs_vv = lch.diff2(cs_v)
#
t = numpy.linspace(ta, tb, n0)
uv = chebval(t, cc)
uv_t = chebval(t, cc_t)
xyz = chebval2d(uv[0], uv[1], cs)
xyz_u = chebval2d(uv[0], uv[1], cs_u)
xyz_v = chebval2d(uv[0], uv[1], cs_v)
xyz_uu = chebval2d(uv[0], uv[1], cs_uu)
xyz_uv = chebval2d(uv[0], uv[1], cs_uv)
xyz_vv = chebval2d(uv[0], uv[1], cs_vv)
curvature = numpy.maximum(
EPS,
normal_curvature(xyz_u, xyz_v, xyz_uu, xyz_uv, xyz_vv, uv_t[0],
uv_t[1]))
hminsqr = hmin**2
hmaxsqr = hmax**2
hsqr = numpy.minimum(hmaxsqr, numpy.maximum(hminsqr,
FRACsqr / curvature**2))
#
maxit = 100 * n0
for it in range(maxit):
changes = False
for i in range(len(t) - 1):
ei = xyz[:, i + 1] - xyz[:, i]
lisqr = ei.dot(ei)
if lisqr > 2 * max(hsqr[i], hsqr[i + 1]):
# split
hi = numpy.sqrt(hsqr[i])
hj = numpy.sqrt(hsqr[i + 1])
tm = (hj * t[i] + hi * t[i + 1]) / (hi + hj)
uvm = chebval(tm, cc)
uvm_t = chebval(tm, cc_t)
xyzm = chebval2d(uvm[0], uvm[1], cs)
xyzm_u = chebval2d(uvm[0], uvm[1], cs_u)
xyzm_v = chebval2d(uvm[0], uvm[1], cs_v)
xyzm_uu = chebval2d(uvm[0], uvm[1], cs_uu)
xyzm_uv = chebval2d(uvm[0], uvm[1], cs_uv)
xyzm_vv = chebval2d(uvm[0], uvm[1], cs_vv)
curvaturem = numpy.maximum(
EPS,
normal_curvature(xyzm_u, xyzm_v, xyzm_uu, xyzm_uv, xyzm_vv,
uvm_t[0], uvm_t[1]))
hmsqr = numpy.minimum(
hmaxsqr, numpy.maximum(hminsqr, FRACsqr / curvaturem**2))
t = numpy.insert(t, i + 1, tm)
uv = numpy.insert(uv, i + 1, uvm, axis=1)
xyz = numpy.insert(xyz, i + 1, xyzm, axis=1)
hsqr = numpy.insert(hsqr, i + 1, hmsqr)
changes = True
break
elif lisqr < 0.5 * min(hsqr[i], hsqr[i + 1]):
if xyz.shape[1] <= 2: break
# collapse
if i == 0:
# remove i+1
t = numpy.delete(t, i + 1)
uv = numpy.delete(uv, i + 1, axis=1)
xyz = numpy.delete(xyz, i + 1, axis=1)
hsqr = numpy.delete(hsqr, i + 1)
elif i == xyz.shape[1] - 2:
# remove i
t = numpy.delete(t, i)
uv = numpy.delete(uv, i, axis=1)
xyz = numpy.delete(xyz, i, axis=1)
hsqr = numpy.delete(hsqr, i)
else:
# relocate i+1
hi = numpy.sqrt(hsqr[i])
hj = numpy.sqrt(hsqr[i + 1])
t[i + 1] = (hj * t[i] + hi * t[i + 1]) / (hi + hj)
uv[:, i + 1] = chebval(t[i + 1], cc)
uvm_t = chebval(t[i + 1], cc_t)
xyz[:, i + 1] = chebval2d(uv[0, i + 1], uv[1, i + 1], cs)
xyzm_u = chebval2d(uv[0, i + 1], uv[1, i + 1], cs_u)
xyzm_v = chebval2d(uv[0, i + 1], uv[1, i + 1], cs_v)
xyzm_uu = chebval2d(uv[0, i + 1], uv[1, i + 1], cs_uu)
xyzm_uv = chebval2d(uv[0, i + 1], uv[1, i + 1], cs_uv)
xyzm_vv = chebval2d(uv[0, i + 1], uv[1, i + 1], cs_vv)
curvaturem = numpy.maximum(
EPS,
normal_curvature(xyzm_u, xyzm_v, xyzm_uu, xyzm_uv,
xyzm_vv, uvm_t[0], uvm_t[1]))
hsqr[i + 1] = numpy.minimum(
hmaxsqr, numpy.maximum(hminsqr,
FRACsqr / curvaturem**2))
# remove i
t = numpy.delete(t, i)
uv = numpy.delete(uv, i, axis=1)
xyz = numpy.delete(xyz, i, axis=1)
hsqr = numpy.delete(hsqr, i)
changes = True
break
else:
continue
if not changes: break
#
"""
for i in range(len(t)):
if i == 0:
print('%s' % numpy.sqrt(hsqr[i]))
else:
print('%s\t%s' % (
numpy.sqrt(hsqr[i]),
numpy.sqrt(numpy.dot(xyz[:,i] - xyz[:,i-1], xyz[:,i] - xyz[:,i-1]))
))
"""
#
return xyz, uv, t
def __call__(self, y, x, shifts=None):
cy, cx = self.coord(y, x, shifts)
return chebval2d(cy, cx, self.coef)
vislim = [vislim[0], vismid]
#
x, y = lbf.convert_3d_to_2d_coords(xyzmid, normalize=True)
edge_vis.append([x, y])
edge_hid.append([x, y])
# EXPORT XY CURVES
numpy.savetxt(pthout + 'edge_visible.dat', edge_vis)
numpy.savetxt(pthout + 'edge_hidden.dat', edge_hid)
################################################################
################################################################
# ISO-U CURVE
u0 = -0.6
v0 = 0.05
isou_xyz = chebval2d(u0 * numpy.ones(n), v, c).T
isou = lbu.pydata_to_polyline(isou_xyz,
name='isou',
thickness=1e-3,
bevel_resolution=4,
fill_mode='FULL')
isou.hide_render = True
isou_xy = numpy.zeros((n, 2))
for i in range(n):
isou_xy[i] = lbf.convert_3d_to_2d_coords(isou_xyz[i], normalize=True)
numpy.savetxt(pthout + 'iso-u_curve.dat', isou_xy)
e = chebval2d(u0, v0, c)
bpy.ops.object.empty_add(location=e)
def full_model(self, points, *params):
""""""
return chebval2d(points[:, 0], points[:, 1],
self.params_to_coeff(params))
nf = 31
for iface in range(nf):
strf = format(iface + 1, '03')
print('\nface #', iface + 1)
print(' load pydata...')
tri = numpy.loadtxt(pthin + 'brepmesh' + suffixe + '/tri_' + strf + '.dat',
dtype=int) - 1
uv = numpy.loadtxt(pthin + 'brepmesh' + suffixe + '/uv_' + strf + '.dat',
dtype=float)
c = myl.readCoeffs(pthin + 'brepmesh' + suffixe + '/c_' + strf + '.cheb')
c_u, c_v = lch.diff2(c)
c_uu, c_uv = lch.diff2(c_u)
c_uv, c_vv = lch.diff2(c_v)
xyz = chebval2d(uv[:, 0], uv[:, 1], c).T
verts = [[float(x) for x in p] for p in xyz]
faces = [[int(v) for v in t] for t in tri]
print(' pydata to mesh...')
obj = lbu.pydata_to_mesh(verts, faces, name='face_' + strf)
scene.objects.active = obj
lbe.set_smooth(obj)
print(' diffgeom...')
# Diffgeom
nor = []
curvatures = []
for u in uv:
dxyz_du = chebval2d(u[0], u[1], c_u)
numpy.sum(xyz_u * xyz_v, axis=0)**2)
nor = numpy.zeros((3, m, m))
for i in range(3):
j = (i + 1) % 3
k = (j + 1) % 3
nor[i] = (xyz_u[j] * xyz_v[k] - xyz_u[k] * xyz_v[j]) * invsqrtdet
xyz = xyz + rho * nor
mverts, mfaces = lbu.tensor_product_mesh_vf(xyz[0], xyz[1], xyz[2])
obj = lbu.pydata_to_mesh(mverts, mfaces, name='EdS_face_' + strf)
lbe.set_smooth(obj)
obj.data.materials.append(mat)
# NORMAL AT VERTEX
xyz = chebval2d(Vuv[iloc][0], Vuv[iloc][1], c)
xyz_u = chebgrid2d(Vuv[iloc][0], Vuv[iloc][1], cu)
xyz_v = chebgrid2d(Vuv[iloc][0], Vuv[iloc][1], cv)
nor = Vector(xyz_u).cross(Vector(xyz_v))
nor.normalize()
normals.append(nor)
################################################################
################################################################
# OFFSET EDGES
ih = 2 * V.edge[0] + V.edge[1]
arcs = []
xyz_edges = []
iclr = [15, 29, 16]
#xyz_facelabel = []
normals = []
xyz_facecenter = []
for iloc, iface in enumerate(V.faces):
strf = format(iface, '03')
mat = bpy.data.materials.new('mat_face_' + strf)
mat.diffuse_color = color_face[iface - 1]
c = lcheb.read_polynomial2(pthin + 'brepmesh/c_' + strf + '.cheb')
cu, cv = lcheb.diff2(c)
xyz_u = chebgrid2d(Vuv[iloc][0], Vuv[iloc][1], cu)
xyz_v = chebgrid2d(Vuv[iloc][0], Vuv[iloc][1], cv)
normals.append(Vector(xyz_u).cross(Vector(xyz_v)).normalized())
xyz_facecenter.append(chebval2d(0, 0, c))
normal_avg = Vector((0, 0, 0))
for nor in normals:
normal_avg += nor
normal_avg.normalize()
################################################################
################################################################
# ADJUST CAMERA
# align with average normal at vertex
cam.rotation_mode = 'QUATERNION'
cam.rotation_quaternion = Vector(normal_avg).to_track_quat('Z', 'Y')
# fit view
bpy.ops.object.select_all(action='DESELECT')
xyz = chebgrid2d(u, u, c)
mverts, mfaces = lbu.tensor_product_mesh_vf(xyz[0], xyz[1], xyz[2])
obj = lbu.pydata_to_mesh(mverts, mfaces, name='face_' + strf)
lbe.set_smooth(obj)
obj.data.materials.append(mat)
# OFFSET
c = lcheb.read_polynomial2(pthin + 'brepmesh_eos/c_' + strf + '.cheb')
xyz = chebgrid2d(u, u, c)
mverts, mfaces = lbu.tensor_product_mesh_vf(xyz[0], xyz[1], xyz[2])
obj = lbu.pydata_to_mesh(mverts, mfaces, name='EdS_face_' + strf)
lbe.set_smooth(obj)
obj.data.materials.append(mat)
#
xyz = chebval2d(Vuv[iloc][0], Vuv[iloc][1], c)
corners.append(xyz)
corner_avg = numpy.zeros(3)
for xyz in corners:
corner_avg = corner_avg + xyz
corner_avg = corner_avg / len(corners)
# SPHERE RADIUS
rho = 0
for xyz in corners:
rho += Vector(xyz - V.xyz).length
rho /= float(len(corners))
bpy.ops.mesh.primitive_uv_sphere_add(location=V.xyz,
size=rho,
def trace_intersection_curve(patches, hmin, hmax, tolchord):
xc = [Pa.get_corners() for Pa in patches]
for jc in range(4):
for ic in range(4):
v1 = xc[0][ic] - xc[1][(jc + 1) % 4]
v2 = xc[0][(ic + 1) % 4] - xc[1][jc]
if max(v1.dot(v1), v2.dot(v2)) < EPS**2:
jvar = ic2ivar[jc]
jval = ic2ival[jc]
ivar = ic2ivar[ic]
ival = ic2ival[ic]
if NORMAL_CURVATURE_ONLY:
xyz, uvtmp, t = discretize_curve_on_surface(
uvborders_c[jc],
cht_xyz(patches[1].xyz),
hmin,
hmax,
tolchord,
ta=-1,
tb=1)
uv = numpy.zeros((2, 2, len(t)))
uv[1] = uvtmp
uv[0, ivar, :] = (-1)**ival
uv[0, (ivar + 1) % 2] = numpy.sign(1.5 - ic) * t
else:
xyz = patches[1].get_border(jc)
c = lch.fcht(xyz).T
xyz, t = discretize_curve(c,
hmin,
hmax,
tolchord,
ta=1,
tb=-1)
uv = numpy.zeros((2, 2, len(t)))
uv[1, jvar, :] = (-1)**jval
uv[1, (jvar + 1) % 2] = numpy.sign(1.5 - jc) * t
uv[0, (ivar + 1) % 2] = -numpy.sign(1.5 - ic) * t
uv[0, ivar, :] = (-1)**ival
#print([p.index for p in patches], ic, uv[0])
print(
'ic = %d, uv0a = (%s, %s), uv0b = (%s, %s)' %
(ic, uv[0, 0, 0], uv[0, 1, 0], uv[0, 0, -1], uv[0, 1, -1]))
print(
'jc = %d, uv1a = (%s, %s), uv1b = (%s, %s)' %
(jc, uv[1, 0, 0], uv[1, 1, 0], uv[1, 0, -1], uv[1, 1, -1]))
for k, l in enumerate([ic, jc]):
ck = cht_xyz(patches[k].xyz)
xka = chebval2d(uv[k, 0, 0], uv[k, 1, 0], ck)
xkb = chebval2d(uv[k, 0, -1], uv[k, 1, -1], ck)
print('err / x%da = %s' %
(k,
numpy.sqrt(
numpy.sum((xka - xc[k][(l + 1 - k) % 4])**2))))
print(
'err / x%db = %s' %
(k, numpy.sqrt(numpy.sum(
(xkb - xc[k][(l + k) % 4])**2))))
print('\n\n')
#xyz = chebval2d(uv[0,0], uv[0,1], cht_xyz(patches[0].xyz))
return Curve_t(patches=patches, xyz=xyz, uv=uv)
return None
for k in range(1,6):
y[k-1]=5+5*mt.cos(((2*k-1)*mt.pi)/(2*5))#Chebycheff nodes function
xx, yy = np.meshgrid(x, y)
xx = xx.reshape(20,1)# X coordinate
yy = yy.reshape(20,1)# Y coordinate
D = cheb2d(xx,yy,n)#Explicative variables.
f = ((3/4)*(xx)**(-3)+((1/4)*(yy)**(-3)))**(-(1/3))
model = sm.OLS(f,D)
results = model.fit()
p = results.params
x = np.linspace(0,10,40)
y = np.linspace(0,10,40)
xx, yy = np.meshgrid(x, y)
f = ((3/4)*(xx)**(-3)+((1/4)*(yy)**(-3)))**(-(1/3))
w = chebval2d(xx,yy,p)
fig = plt.figure()
ax = fig.gca(projection='3d')
surf = ax.plot_surface(xx, yy, f, cmap=cm.coolwarm,
linewidth=0, antialiased=False)
print('Production function CES, axes X = K, axes Y = L and axes Z = Output')
fig = plt.figure()
ax = fig.gca(projection='3d')
surf = ax.plot_surface(xx, yy, w, cmap=cm.coolwarm,
linewidth=0, antialiased=False)
plt.show()
print('Production function CES chebycheff aproximation, axes X = K, axes Y = L and axes Z = Output')
def gendata(cums,nsub,data,tpsub=0,tpsubn=0,last=False,first=True): print(cums) data=np.concatenate((np.zeros([2,npol,nchan]),data,np.zeros([2,npol,nchan])),axis=0).transpose(2,1,0) if args.reverse or (not bw_sign): if nchan==chanend: data=data[(nchan-chanstart-1)::-1] else: data=data[(nchan-chanstart-1):(nchan-chanend-1):-1] else: data=data[chanstart:chanend] if args.period: dt=np.array([np.arange(nsblk*cums-1,nsblk*cums+nsub+1)*tsamp]*nchan_new) else: dt=(np.arange(nsblk*cums-2,nsblk*cums+nsub+2)*tsamp+time0[:-1].sum()-delay-t0)/(t1-t0)*2-1 for f in np.arange(nchan_new): if f+chanstart in zchan: continue if args.period: if dm: phase=(dt+dm/df[f]**2*4148.808)/period else: phase=dt/period else: phase=nc.chebval2d(dt,df0[f]*np.ones_like(dt,dtype=np.float64),coeff)+dispc/df[f]**2 newphase=np.arange(phase[0]//dphasebin+1,phase[-1]//dphasebin+1,dtype=np.int64) if newphase[-1]<0 or newphase[0]>=totalbin: continue newphase=newphase[(newphase>=0) & (newphase<totalbin)] tpdata=np.zeros([npol,len(newphase)]) for p in np.arange(npol): tpdata[p]=np.interp(newphase,phase/dphasebin,data[f,p,:]) if temp_multi>1: startphase,phaseres0=divmod(newphase[0],temp_multi) phaseres0=np.int64(phaseres0) nphase=np.int64(np.ceil((newphase[-1]+1-newphase[0]+phaseres0)*1.0/temp_multi)) tpdata=np.concatenate((np.zeros([npol,phaseres0]),tpdata,np.zeros([npol,nphase*temp_multi-newphase[-1]-1+newphase[0]-phaseres0])),axis=1).reshape(npol,nphase,temp_multi).sum(2) else: startphase=newphase[0] nphase=newphase.size if info['mode']=='single': write_data(d,tpdata,startphase,f) else: startperiod,phaseres1=divmod(startphase,nbin) phaseres1=np.int64(phaseres1) file_nperiod=np.int64(np.ceil((nphase+phaseres1)*1.0/nbin)) startsub,periodres=divmod(startperiod,sub_nperiod) periodres=np.int64(periodres) file_nsub=np.int64(np.ceil((file_nperiod+periodres)*1.0/sub_nperiod)) if file_nsub>1 or newphase[-1]==totalbin-1: file_sub_data=np.zeros([npol,file_nsub,nbin]) if newphase[-1]==totalbin-1: if newphase[0]==0: tpdata=tpdata.reshape(npol,-1,nbin) file_sub_data[:,:-1]=tpdata[:,:(-sub_nperiod_last)].reshape(npol,file_nsub-1,sub_nperiod,nbin).sum(2) file_sub_data[:,-1]=tpdata[:,(-sub_nperiod_last):].sum(1) elif file_nsub>1: tpsub[f,:,phaseres1:]+=tpdata[:,:(nbin-phaseres1)] tpdata=tpdata[:,(nbin-phaseres1):].reshape(npol,-1,nbin) file_sub_data[:,1:-1]=tpdata[:,(sub_nperiod-periodres-1):(-sub_nperiod_last)].reshape(npol,file_nsub-2,sub_nperiod_last,nbin).sum(2) file_sub_data[:,0]=tpsub[f]+tpdata[:,:(sub_nperiod-periodres-1)].sum(1) file_sub_data[:,-1]=tpdata[:,(-sub_nperiod_last):].sum(1) else: tpsub[f,:,phaseres1:]+=tpdata[:,:(nbin-phaseres1)] tpdata=tpdata[:,(nbin-phaseres1):].reshape(npol,-1,nbin) file_sub_data[:,0]=tpsub[f]+tpdata.sum(1) write_data(d,file_sub_data.reshape(npol,-1),startsub*nbin,f) else: periodres_left=sub_nperiod-periodres periodres_right=(file_nsub-1)*sub_nperiod-periodres phaseres_left=periodres_left*nbin-phaseres1 phaseres_right=periodres_right*nbin-phaseres1 phaseres_left1=nbin-phaseres1 phaseres_right1=(file_nperiod-1)*nbin-phaseres1 file_sub_data[:,1:-1]=tpdata[:,phaseres_left:phaseres_right].reshape(npol,file_nsub-2,sub_nperiod,nbin).sum(2) file_sub_data[:,0]=tpdata[:,phaseres_left1:phaseres_left].reshape(npol,sub_nperiod-periodres-1,nbin).sum(1) file_sub_data[:,0,phaseres1:]+=tpdata[:,:phaseres_left1] file_sub_data[:,-1]=tpdata[:,phaseres_right:phaseres_right1].reshape(npol,file_nperiod-1-periodres_right,nbin).sum(1) file_sub_data[:,-1,:(nphase-phaseres_right1)]+=tpdata[:,phaseres_right1:] if tpsubn[f]<=startsub: file_sub_data[:,0]+=tpsub[f] else: file_sub_data[:,1]+=tpsub[f] write_data(d,file_sub_data[:,:-1].reshape(npol,-1),startsub*nbin,f) tpsub[f]=file_sub_data[:,-1] tpsubn[f]=startsub+file_nsub-1 if args.multi and last: write_data(d,tpsub[f],tpsubn[f]*nbin,f) else: if file_nperiod>1: phaseres_left=nbin-phaseres1 phaseres_right=(file_nperiod-1)*nbin-phaseres1 tpsub[f,:,phaseres1:]+=tpdata[:,:phaseres_left] tpsub[f,:,:(nphase-phaseres_right)]+=tpdata[:,phaseres_right:] if file_nperiod>2: tpsub[f]+=tpdata[:,phaseres_left:phaseres_right].reshape(npol,file_nperiod-2,nbin).sum(1) else: tpsub[f,:,phaseres1:(phaseres1+tpdata.shape[1])]+=tpdata if args.multi and last: write_data(d,tpsub[f],startsub*nbin,f) return tpsub,tpsubn
curv3 = lbu.pydata_to_mesh(
xyz.T,
faces=[],
edges=[(i, i+1) for i in range(len(t)-1)],
name='curve3'
)
uvw = numpy.vstack([uv, numpy.zeros(len(t))])
curv2 = lbu.pydata_to_mesh(
uvw.T,
faces=[],
edges=[(i, i+1) for i in range(len(t)-1)],
name='curve2'
)
curv2.layers[1] = True
curv2.layers[0] = False
w = numpy.linspace(-1,1,300)
uv = chebval(w, cc)
xyz = chebval2d(uv[0], uv[1], cs)
unif3 = lbu.pydata_to_mesh(
xyz.T,
faces=[],
edges=[(i, i+1) for i in range(len(w)-1)],
name='uniform3'
)
mat.use_shadows = False
mat.use_shadeless = True
mat.use_cast_buffer_shadows = False
slot = mat.texture_slots.add()
slot.texture = texchecker
slot.texture_coords = 'UV'
slot.diffuse_color_factor = 1
################################################
# Face label
fid = numpy.loadtxt(pthout + 'faces/faces_id.dat', dtype=int)
stlabel = numpy.loadtxt(pthout + 'faces/face_uvlabel_' + strf + '.dat',
delimiter=',')
xyzfacelabel = chebval2d(stlabel[0], stlabel[1], c)
myl.addEmpty('label', xyzfacelabel)
u, v = lbf.convert_3d_to_2d_coords(xyzfacelabel)
f = open(pthout + 'faces/face_xyzlabel_' + strf + '.dat', 'w')
f.write(str(fid[iface] + 1) + ', ' + str(u) + ', ' + str(v))
f.close()
################################################
# Freestyle settings
freestyle = scene.render.layers.active.freestyle_settings
freestyle.use_smoothness = True
bpy.ops.scene.freestyle_lineset_add() #2
Z3 = Z1*Z2 fig3 = plt.figure() ax3 = fig3.add_subplot(111,projection='3d') ax3.plot_surface(X,Y,Z3) plt.show() z4 = cheb.chebval2d(x,y, F1_mat) print(z4.size) fig4 = plt.figure() ax4 = fig4.add_subplot(111,projection='3d') ax4.plot_surface(x,y,z4) plt.show() #chebz = cheb.chebgrid2d(x,y) x1_pol = [-4, .2, .1] y1_pol = [0, -.6, .2] # #x1_cheb = cheb.cheb2poly(x1_pol) #y1_cheb = cheb.cheb2poly(y1_pol) #cheb_X = cheb.chebval(-5, x1_cheb) #cheb_Y = cheb.chebval(-5, y1_cheb) #p_X = fx1(X) #p_Y = fy1(Y)
