def testModifGlobales(filename, show=True):
debug(titre="testModifGlobales : %s" % filename.name)
# numfig = 0
# plt.figure(numfig)
S0 = NSplineSimple(points=pointsFromFile(filename),
methode=('cubic', ((2, 0, 0), (1, 0, -5))),
precision=1000,
mode='courbure',
name='SPLINE01')
if show: S0.plot(titre='NSplineSimple(points=pointsFromFile(filename),...')
# numfig += 1
# plt.figure(numfig)
S0.cpoints = pointsFromFile(filename)
debug(initial=mesures(S0))
if show: S0.plot(titre=filename.name + 'cpoints = pointsFromFile()')
# numfig += 1
# plt.figure(numfig)
S0.symetriser(0)
debug(symetriser_0=mesures(S0))
if show: S0.plot(titre='symetriser(0)')
# numfig += 1
# plt.figure(numfig)
S0.symetriser(1)
debug(symetriser_1=mesures(S0))
if show: S0.plot(titre='symetriser(1)')
# numfig += 1
# plt.figure(numfig)
S0.hardRotate(30) #en degres par defaut
debug(hardRotate_30=mesures(S0))
if show: S0.plot(titre='hardRotate(30)')
# numfig += 1
# plt.figure(numfig)
S0.hardScale((2, 0.5))
debug(hardScale_2_0point5=mesures(S0))
if show: S0.plot(titre='hardScale((2,0.5))')
# numfig += 1
# plt.figure(numfig)
S0.translate((2, 3))
debug(translate_2_3=mesures(S0))
if show: S0.plot(titre='translate((2,3))')
# if show : plt.show()
debug(titre="Fin testModifGlobales : %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)