def testSequenceBasique(filename, show=True):
"""Une séquence basique d'utilisation de spline"""
debug(titre='testSequenceBasique %s' % filename.name)
debug(show=show)
# exit()
debug(paragraphe='0. NSplineSimple() ')
S = NSplineSimple()
debug(S=S)
c, d, knots = S.cpoints, S.dpoints, S.knots
print 'cpoints =', c, type(c), c.shape
print 'dpoints =', d, type(d), d.shape
print ' knots =', knots, type(knots), knots.shape
debug(titre='differentes methodes %s' % filename.name)
for k, methode in enumerate((
('us', 1), #'linear'),
# ('us',2),#'linear'),
('us', 3), #'courbure'),
# ('us',4),#'courbure'),
# ('us',7),#'courbure'),
('ius', 1), #'courbure'),
('ius', 3), #'courbure'),
# ('lsqus',1),#'linear'),
# ('lsqus',2),#'linear'),
# ('lsqus',3),#'courbure'),
# ('lsqus',4),#'courbure'),
('cubic', 'not-a-knot'),
('cubic', 'periodic'),
('cubic', 'natural'),
('cubic', ((1, 0, -5), (1, 0, -5))),
('cubic', ((2, 0, 0), (1, 0, -5))), #extrados
('cubic', ((1, 0, -5), (2, 0, 0))), #intrados
# ('ius',7),#'courbure'),
)):
debug(paragraphe='1. methode-%d=%s (fichier %s)' %
(k, str(methode), filename.name))
S = NSplineSimple(cpoints=pointsFromFile(filename),
methode=methode,
name=str(methode))
debug(S)
debug(u' Normal, S.dpoint est calcule', lendpoints=len(S.dpoints))
debug(paragraphe='2. S._update() methode-%d=%s (fichier %s)' %
(k, str(methode), filename.name))
S._update()
try:
debug(S._dpoints)
except AttributeError as msg:
debug(u' Normal pas de S._dpoints : %s' % str(msg))
debug(u' Normal, S.dpoint est calcule', lendpoints=len(S.dpoints))
debug(S)
if show:
S.plot(show=True)
debug(' Longueurs (c,d)=(%.5g,%.5g) ; nspline=%d' %
(S.longueur('c'), S.longueur('d'), S.nbspline))
i, p = len(S) / 2, S.centregravite
debug(paragraphe='3. S[%d]=[%.3g, %.3g], methode-%d=%s (fichier %s)' %
(i, p[0], p[1], k, str(methode), filename.name))
oldp = S[i].copy()
S[i] = p
debug(S[i], oldp=oldp)
debug(' Longueurs (c,d)=(%.5g,%.5g) ; nspline=%d' %
(S.longueur('c'), S.longueur('d'), S.nbspline))
debug(' S(1)=%s' % S(1.0)) #ne donne pas tout a fait cpoints[-1]
ac = absCurv(S._cpoints, normalise=True)
print ' abscurv=', ac.shape, 'knots=', S.knots.shape, 'cpoints=', S._cpoints.shape
print ' norm(S(ac)-S._cpoints)=', norm(S(ac) - S._cpoints)
print ' norm(ac-S.knots)', norm(ac - S.knots)
if show:
S.plot(show=True,
titre='%s : modif S[%d]=[%.3g, %.3g]' %
(filename.name, i, p[0], p[1]))
debug(S[i], oldp=oldp)
S[i] = oldp
debug(paragraphe='4. echantillonnage methode-%d=%s (fichier %s)' %
(k, str(methode), filename.name))
S.nbpe = 120
print 'mode=', S.mode, ', epoints=', S.epoints.shape
e0, mode0 = S.epoints, S.mode
print 'mode=', S.mode, ', epoints=', e0.shape
print 'T = %s' % S.tech.tolist()
S.mode = 'cos' #efface tech et epoints
e1, mode1 = S.epoints, S.mode
print 'mode=', S.mode, ', epoints=', e0.shape
print 'T = %s' % S.tech.tolist()
#on regarde si ca se recalcule bien apres suppression epoints et tech
del S._epoints, S._tech
e2, mode2 = S.epoints, S.mode
print 'mode=', S.mode, ', epoints=', e2.shape
print 'T = %s' % S.tech.tolist()
print 'epoints norme(e1-e2)=%.3g' % norm(e1 - e2)
S.mode = 'x3' #efface tech et epoints
e2, mode2 = S.epoints, S.mode
print 'mode=', S.mode, ', epoints=', e2.shape
print 'T = %s' % S.tech.tolist()
S.mode = 'courbure' #efface tech et epoints
mode3 = S.mode
try:
e3, mode3 = S.epoints, S.mode
print 'mode=', S.mode, ', epoints=', e3.shape
print 'T = %s' % S.tech.tolist()
X3, Y3 = XY(e3)
except ValueError as msg: #normal
debug('normal', str(msg))
print 'methode %s, mode echantillonnage = %s : %s' % (str(
S.methode), str(S.mode), str(msg))
X3, Y3 = zeros((0, )), zeros((0, ))
X0, Y0 = XY(e0)
X1, Y1 = XY(e1)
X2, Y2 = XY(e2)
# if show : S.plot(plt,show=True)
if show:
# plt.plot(X0,Y0,'r.-',label='%s : mode=%s'%(S.name,mode0))
plt.plot(X1, Y1, 'b.-', label='%s : mode=%s' % (S.name, mode1))
# plt.plot(X2,Y2,'k.-',label='%s : mode=%s'%(S.name,mode2))
plt.plot(X3, Y3, 'm.-', label='%s : mode=%s' % (S.name, mode3))
plt.legend()
plt.axis('equal')
plt.show()
debug(titre='Fin testSequenceBasique %s' % filename.name)
def testPlacementRM(show=True):
##############################################
### debut construction exemple
##############################################
debug(titre="testPlacementRM : pas de fichier")
debug()
B1 = asarray(
[[0, 0], [0.5, 0.25], [0.5, 0.8], [0, 1.1], [0, 1.7], [0.5, 2]],
float) #un S
B2 = asarray([[2, 0], [2.5, 1], [2, 2]], float) #un C à l'envers
# delta = 0.0186#distance entre reperes de montage (en m)
s1 = NSplineSimple(
cpoints=B1,
parent=None,
# methode=('ius',1),
methode=('cubic', 'natural'),
name='B1',
)
s2 = NSplineSimple(
cpoints=B2,
parent=None,
# methode=('ius',1),
methode=('cubic', 'natural'),
name='B2',
)
# ac1 = absCurv(s1.cpoints, normalise=False)
# ac2 = absCurv(s2.cpoints, normalise=False)
l1, l2 = s1.longueur(), s2.longueur()
debug(u'avant hardScale', l1=l1, l2=l2)
#Je les ramène à la même longueur
s2.hardScale((l1 / l2, l1 / l2))
l1, l2 = s1.longueur(), s2.longueur()
lref = min(l1, l2)
debug(u'après hardScale', l1=l1, l2=l2)
B1, B2 = s1.epoints, s2.epoints #le tableaux echantillonnés que va me passer ML
##############################################
### fin construction exemple
##############################################
delta = 0.2 #distance entre reperes de montage (en m)
s1, s2, T = placementReperesMontage(
B1,
B2,
delta,
)
n = len(T)
rm1, rm2 = s1(T), s2(T)
ac1, ac2 = s1.abscurv(T), s2.abscurv(T) #les abs curv. vraies des reperes
delta1 = ac1[1:] - ac1[:-1]
delta2 = ac2[1:] - ac2[:-1]
dd = np.max(np.abs(delta1 - delta2))
debug("Erreur : %.1e mm" % (1000 * dd / lref))
plt.plot(s1.dpoints[:, 0], s1.dpoints[:, 1], 'b-')
plt.plot(s1.cpoints[:, 0],
s1.cpoints[:, 1],
'bx',
label=u'Points de contrôle des splines')
plt.plot(s2.dpoints[:, 0] - 1, s2.dpoints[:, 1], 'b-')
plt.plot(s2.cpoints[:, 0] - 1, s2.cpoints[:, 1], 'bx')
plt.plot(rm1[:, 0], rm1[:, 1], 'ro', label=u'Repères de montage')
plt.plot(rm2[:, 0] - 1, rm2[:, 1], 'ro')
plt.axis('equal')
plt.legend()
msg = u"""Deux bords de pièces à assembler, de longueur $l_1$=%.4g m $\simeq$ $l_2$=%.4g m
Placements de %d repères de montage espacés de %.2g m.
L'erreur est de %.2f mm soit %.2f‰""" % (l1, l2, n, delta, 1000 * dd,
1000 * dd / lref)
plt.title(msg)
if show: plt.show()
debug(titre="Fin testPlacementRM : pas de fichier")
def testDivers(filename, show=True):
name = filename.name
debug(titre="testDivers : %s" % name)
msg = u"""Dans cet exemple, on a des points doubles p4=p5=p6 et p8=p9,
donc la spline x(t) ne peut pas être construite.
Que faire ?
- supprimer p[6] <=== Oui c'est la solution adoptée ici
- déplacer légèrement le point
- faire une spline composée, splittée en 6
"""
debug(msg)
cpoints = pointsFromFile(filename)
S0 = NSplineSimple(cpoints=cpoints, name=filename.name)
debug(S0)
if show: S0.plot(show=True)
########################################
msg = u"""S est une NSplineSimple. Teste les méthodes :
- S.absCurv(T) qui retourne les abscisses curvilignes VRAIES des points S(T)
- S.longueur('x') =
# longueur vraie(x=r) par intégration numérique
# longueur du polyligne S.[cpoints,dpoints,epoints] 'x'=['c','d','e']
- S.projection(p) et affiche le résultat pour 3 points
Calcule la distance du point 'p' à la spline 'S' et le point 'h' de la spline
le plus proche de 'p'. Retourne également la precision et le nb d'appels à fonction
Utilise :
"https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize_scalar.html
"""
dump = {
'classename': 'NSplineSimple',
'cpoints': cpoints,
'methode': ('cubic', 'not-a-knot'),
# 'mode': 'segment',
# 'methode': ('ius', 1),
'mode': 'rayon',
# 'mode': 'cpoints',
'name': filename.name,
'nbpe': 30,
'precision': 1000,
'role': 'NSplineSimple'
}
dump = {
'cpoints': [[0.5279636979103088, 0.07332829385995865],
[0.7137287259101868, 0.3275330364704132],
[1.268811468596966, 0.3365727279966774],
[1.1390328407287598, 0.07332829385995865],
[1.2571670716747245, 0.2148051133421408],
[1.2206038430660453, -0.0507648238639925],
[1.5545598268508911, -0.0048885527066886425]],
# 'methode': ('cubic', 'not-a-knot'),
'methode': ('ius', 3),
'name':
u'test',
'nbpe':
30,
'precision':
1000,
'mode':
'linear'
}
debug(msg)
S = NSplineSimple(**dump)
if show: S.plot()
knots = S.knots
acn = S.absCurv(knots)
acr = S.absCurv(acn)
debug('S.absCurv(None)', acn.tolist())
debug('S.knots', knots.tolist())
l = S.longueur()
debug('(acr-acn)*longueur', (acr - acn * l).tolist())
debug('longueur=%.10g' % l)
lr = acr[-1]
debug('vraie abscurv[-1]=%.10g' % lr)
ln = acn[-1]
debug('abscurv[-1]=%.10g' % ln)
S.nbpd = 100
ld3 = S.longueur('d')
debug('S.dlongueur=%g' % ld3 + u"(calculé sur %d points)" % S.precision)
S.nbpd = 1000
ld4 = S.longueur('d')
debug('S.dlongueur=%g' % ld4 + u"(calculé sur %d points)" % S.precision)
S.nbpd = 10000
ld5 = S.longueur('d')
debug('S.dlongueur=%g' % ld5 + u"(calculé sur %d points)" % S.precision)
le = S.longueur('e')
debug('S.elongueur=%g' % le)
lc = S.longueur('c')
debug('S.clongueur=%g' % lc)
if show:
diff = [l - lr, l - ln, l - ld3, l - ld4, l - ld5, l - le, l - lc]
plt.show()
plt.bar(range(len(diff)), diff)
plt.xticks(range(len(diff)), 'lr,ln,ld3,ld4,ld5,le,lc'.split(','))
plt.title('differentes longueurs calculees')
p1, p2, p3 = [0.2, 0.01], [1.1, 0.2], [-0.1, 0.3]
res1, res2, res3 = S.projection(p1), S.projection(p2), S.projection(p3)
pj1, pj2, pj3 = S(res1[0]), S(res2[0]), S(res3[0])
# debug(str(res))
debug(paragraphe="**** DISTANCE POINT-SPLINE ****")
debug('message="%s"' % res1[3], 'd(S,p1)=%g' % res1[1], 't=%g' % res1[0],
'nb appels a fct=%d' % res1[2])
debug('message="%s"' % res2[3], 'd(S,p2)=%g' % res2[1], 't=%g' % res2[0],
'nb appels a fct=%d' % res2[2])
debug('message="%s"' % res3[3], 'd(S,p3)=%g' % res3[1], 't=%g' % res3[0],
'nb appels a fct=%d' % res3[2])
if show:
more = [([p1[0],
pj1[0]], [p1[1],
pj1[1]], 'g-o', 'd(S,p1) : %.2g' % sqrt(res1[1])),
([p2[0],
pj2[0]], [p2[1],
pj2[1]], 'g-o', 'd(S,p2) : %.2g' % sqrt(res2[1])),
([p3[0],
pj3[0]], [p3[1],
pj3[1]], 'g-o', 'd(S,p3) : %.2g' % sqrt(res3[1]))]
projections = [(pj1[0], pj1[1], 'y.', ''), (pj2[0], pj2[1], 'y.', ''),
(pj3[0], pj3[1], 'y.', '')]
more += projections
S.plot(more=more, titre='distance point-spline', show=True)
# plt.plot(p1[0],p1[1],'go', label='p1 : %g'%res1[1])
# plt.legend()
# if show : plt.show()
# return
debug('ORIGINAL', S=S)
debug(rect=S.boundingRect())
# debug('CLONE', clone=S.clone())
debug('COPY', clone=S.copy())
S.hardScale((0.5, 0.5), S.centregravite)
debug('APRES HARDSCALE', S=S)
debug(rect=S.boundingRect())
S.hardMove((10, 10))
debug('APRES HARDMOVE', S=S)
debug(rect=S.boundingRect())
# debug(top='%g'%rect.top(), left='%g'%rect.left(), width='%g'%rect.width(), height='%g'%rect.height(), )
# debug(bottom='%g'%rect.bottom(), top='%g'%rect.top())
if show: S.plot(titre="**dump")
debug(titre="Fin testDivers : %s" % filename.name)