def testMain(show=False):
p = Profil() #constructeur vide
p.name = u'Vide (3 points)'
debug(titre='Constructeur Vide')
print p
pprint(p.toDump())
files = [
Path(VALIDATION_DIR, 'splinesimple-86pts.spl'),
Path(VALIDATION_DIR, 'profilnormalise-86pts.spl'),
Path(VALIDATION_DIR, 'blocjonc-splinesimple.spl'),
Path(VALIDATION_DIR, 'shark-profilnormalise-86pts.spl'),
Path(VALIDATION_DIR, 'diamirE-profilnormalise-86pts.spl'),
Path(VALIDATION_DIR, 'profilnormalise-21pts.spl'),
Path(VALIDATION_DIR, 'splinesimple-21pts.spl'),
Path(VALIDATION_DIR, 'shark-profilnormalise-26pts.spl'),
Path(VALIDATION_DIR, 'diamirE-profilnormalise-24pts.spl'),
Path(VALIDATION_DIR, 'NACA2415-100pts.spl'),
Path(VALIDATION_DIR, 'points-86pts.gnu'),
Path(VALIDATION_DIR, 'splinesimple-86pts.pkl'),
]
for filename in files[:1]:
if 1: testProfil(filename, show=show)
if 1: testSaveAndOpen(filename, show=show)
if 1: testOuverture(filename, show=show)
if 1: testEchantillonner(filename, show=show)
if 1: testElaguer(filename, show=show)
if 1: testDivers(filename, show=show)
debug(titre='Fin testMain')
def testDivers(filename, show):
name = filename.name
debug(titre="testDivers (%s)" % name)
p = ProfilNormalise()
p.open(filename)
print p
if show: p.plot()
debug(p.echantillonner().tolist())
def testOuverture(filename, show=False):
name = filename.name
debug(titre='testOuverture : %s' % name)
P = Profil(points=pointsFromFile(filename), name='Ouverture')
if show: P.plot(titre='testOuverture:%s' % P.name)
pouv = (-20, -50)
P.pouverture = pouv
if show: P.plot(titre='ouverture=%s' % (str(pouv)))
debug(titre='Fin testOuverture')
def testDivers(filename, show=False):
name = filename.name
debug(titre='testDivers : %s' % name)
if 'spl' in filename.ext:
pass
p = Profil(points=pointsFromFile(filename), precision=[1000, 1000])
debug(rba=p.rba, corde=p.corde)
p.normalise()
debug(rba=p.rba, corde=p.corde)
debug(titre='Fin testDivers')
def testMain(show=False):
files = []
files.append(Path(VALIDATION_DIR,'points-86pts.gnu'))
files.append(Path(VALIDATION_DIR,'diamirE-profilnormalise-86pts.spl'))
files.append(Path(VALIDATION_DIR,'diamirE-profilnormalise-24pts.spl'))
files.append(Path(VALIDATION_DIR,'shark-profilnormalise-26pts.spl'))
files.append(Path(VALIDATION_DIR,'shark-profilnormalise-86pts.spl'))
files.append(Path(VALIDATION_DIR,'NACA2415-100pts.spl'))
files.append(Path(VALIDATION_DIR,'splinesimple-86pts.pkl'))
files.append(Path(VALIDATION_DIR,'splinesimple-86pts.spl'))
files.append(Path(VALIDATION_DIR,'splinesimple-21pts.spl'))
if 1 : testBlocJonc(Path(VALIDATION_DIR,'blocjonc-splinesimple.spl'),show=show)
if 1 : testParticulier(files[6], show=show)
for filename in files[:] :
if 1:testConstructeurs(filename, show=show)
for filename in files[:] :
if 1:testMethodesGlobales(filename, show=show)
for filename in files[:] :
if 1:testMethodesLocales(filename, show=show)
for filename in files[:] :
if 1:testElagage(filename, show=show)
debug(titre='Fin testMain : %s'%filename.name)
def testMain():
files = [
Path(VALIDATION_DIR, 'splinesimple-86pts.spl'),
Path(VALIDATION_DIR, 'profilnormalise-86pts.spl'),
Path(VALIDATION_DIR, 'blocjonc-splinesimple.spl'),
Path(VALIDATION_DIR, 'shark-profilnormalise-86pts.spl'),
Path(VALIDATION_DIR, 'diamirE-profilnormalise-86pts.spl'),
Path(VALIDATION_DIR, 'profilnormalise-21pts.spl'),
Path(VALIDATION_DIR, 'splinesimple-21pts.spl'),
Path(VALIDATION_DIR, 'shark-profilnormalise-26pts.spl'),
Path(VALIDATION_DIR, 'diamirE-profilnormalise-24pts.spl'),
Path(VALIDATION_DIR, 'NACA2415-100pts.spl'),
Path(VALIDATION_DIR, 'points-86pts.gnu'),
Path(VALIDATION_DIR, 'splinesimple-86pts.pkl'),
][::-1]
p = ProfilNormalise()
debug('constructeur vide\n', p)
show = False
for filename in files[:]:
if 1: testPinces(filename, show=show)
if 1: testDivers(filename, show=show)
if 1: testProfilNormalise(filename, show=show)
print '################## FIN main #################'
def testEchantillonnage(filename, trados, show=True):
u"""echantillonnage entre ta et tb. [ta,tb]=[0,1] => echantillonnage complet"""
# s = NSplineSimple(points=pointsFromFile(filename))
u"""Extraction intrados et extrados, normalisation"""
debug(titre="testEchantillonnage %s-trados : %s" % (trados, filename.name))
points = pointsFromFile(filename)
corde, nba = -1.0, np.nan
bf = points[0]
for k, point in enumerate(points):
d = dist2(bf, point)
if d > corde: corde, nba = d, k
corde = math.sqrt(corde)
debug(corde=corde, nba=nba)
points *= (1000 / corde) #en mm
corde = 1000
if trados == 'e': #Extrados
methode = ('cubic', ((2, 0, 0), (1, 0, -corde / 2))) #extrados
c0 = points[:1 + nba]
elif trados == 'i': #Intrados
methode = ('cubic', ((1, 0, -corde / 4), (2, 0, 0))) #intrados
c0 = points[nba:]
u"""Construction et élagage de la spline d'interpolation du trados"""
precision = 1000
# T0 = linspace(0,1,precision)
s0 = NSplineSimple(cpoints=c0,
precision=precision,
methode=methode,
mode='courbure')
# s0.elaguer(1, replace=True)
ne, ta, tb = 30, 0.2, 0.8
s0.echantillonner(nbp=ne, ta=ta, tb=tb, mode='courbure')
debug(Te=s0.tech)
E = s0.epoints
if show:
s0.plot(more=[
(E[:, 0], E[:, 1], 'y^',
'echantillon \nn=%d, %.2f=>%.2f' % (ne, ta, tb)),
])
# plt.plot(E[:,0],E[:,1],'y^','echantillon')
# plt.show()
debug(titre="Fin testEchantillonnage %s-trados : %s" %
(trados, filename.name))
def testMethodes(filename, show=True):
debug(titre='testMethodes(%s)' % filename.name)
k = 0
for methode in (
('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
):
k += 1
S = NSplineSimple(points=pointsFromFile(filename),
methode=methode,
mode='courbure',
name='SPLINE%d' % (k + 1))
debug(S)
if show: S.plot(titre=filename.name + str(methode))
if show: S.plotCourbure()
# filename=Path(VALIDATION_DIR,'simple','simple2d2.gnu')
for methode, mode in (
# (('ius',1),'linear'),
# (('ius',2),'linear'),
# (('ius',3),'courbure'),
(('ius', 4), 'courbure'),
(('ius', 7), 'courbure'),
(('us', 1), 'linear'),
(('us', 2), 'linear'),
(('us', 3), 'courbure'),
(('us', 4), 'courbure'),
(('us', 7), 'courbure'),
):
S = NSplineSimple(points=pointsFromFile(filename),
methode=methode,
mode=mode)
debug(S)
if show and methode[1] <= 5: #pour k=7 ca plante
S.plot(titre=filename.name + str(methode))
debug(titre='Fin testMethodes(%s)' % filename.name)
def testMain(show=True):
# comm = MPI.COMM_WORLD()
# rank = comm.Get_rank()
# size = comm.Get_size()
#for i in range(0,size):
if show:
raw_input(
"show=True : dans PyCharm, il faut exécuter testsplinesimple.py en mode console, dans Liclipse, ca plante... "
)
for filename in files[:]:
if 1:
debug(show=show)
testSequenceBasique(filename, show=show)
return
if 1:
testConstructeurs(filename, show=show)
if 1:
testSaveRead(filename, show=show)
if 1:
testMethodes(filename, show=show)
if 1:
testModifGlobales(filename, show=show)
if 1:
testModifLocales(filename, show=show)
# return
if 1:
testDivers1(filename, show)
if 1:
testDivers(filename, show=show)
if 1:
testEchantillonnage(filename, trados='e', show=show)
testEchantillonnage(filename, trados='i', show=show)
if 1:
testElaguer(filename, trados='i', fonction='elaguer', show=show)
if 1:
testElaguer(filename, trados='e', fonction='elaguer', show=show)
# if 1:
# testElaguer(filename, trados='e', fonction='ajuster',show=show)
# debug('fin testElaguer extrados %s'%filename.name)
# if 1:
# testElaguer(filename, trados='i', fonction='ajuster',show=show)
# debug('fin testElaguer intrados %s'%filename.name)
if 0:
testCorrectionRM(show=show)
if 0:
testPlacementRM(show=show)
debug(titre='fin tests %s' % filename.name)
debug(titre='fin tests')
def testSaveRead(filename, show=True):
u"""Diverses manières de lire, construire, sauvegarder une NSplineSimple"""
debug(titre="testSaveRead : %s" % filename.name)
print " ==> NSplineSimple::__init__()"
S = NSplineSimple(points=pointsFromFile(filename),
methode=('cubic', ((2, 0, 0), (1, 0, -5))),
mode='courbure',
name='SPLINE01')
S4 = NSplineSimple()
S4.load(S.toDump())
dump4 = S4.toDump()
fname = Path(RUNS_DIR, filename.namebase + '#.pkl')
print fname
print " ==> cPickle::dump()/load()"
with open(fname, 'w') as f:
cPickle.dump(S.toDump(), f)
with open(fname, 'r') as f:
dump = cPickle.load(f)
S1 = NSplineSimple(**dump)
# S1.plot(plt)
# if show : plt.show()
dump = S.toDump()
dump1 = S1.toDump()
print 'dump==dump1 ?', dump == dump1
print " ==> file::read()/write() "
fname = Path(RUNS_DIR, filename.namebase + '#.spl')
S2 = NSplineSimple(**dump)
dump2 = S2.toDump()
with open(fname, 'w') as f:
f.write(str(S2.toDump()))
with open(fname, 'r') as f:
dump = eval(f.read())
print " ==> NSplineSimple::load()"
S3 = NSplineSimple(**dump)
dump3 = S3.toDump()
# dump3_1 = S3.toDump()
print 'dump==dump1=dump2=dump3=dump4 ?', dump == dump1 == dump2 == dump3 == dump4
debug(dump=dump)
# debug(dump1=dump1)
# debug(dump2=dump2)
# debug(dump3=dump3)
# debug(dump4=dump4)
# exit()
debug(titre="Fin testSaveRead : %s" % filename.name)
def testParticulier(filename, show):
name = filename.name
debug(titre='testParticulier : (%s)'%name)
methode = [#demi-cercle
('cubic',((1, 0, 3.14), (1, 0, -3.14))),
('cubic',((1, 0, 0), (1, 0, 0)))
]
S = NSplineComposee(points=pointsFromFile(filename),
ruptures=[0,40,-1],
methode=methode,
precision=[10000,10000],
mode=['courbure','courbure'],
nbpe=[100,100],
name=name
)
debug(S)
if show : S.plot()
S.join(1)
if show : S.plot()
debug(titre='Fin testParticulier : (%s)'%name)
def testModifLocales(filename, show=True):
debug(titre="testModifLocales : %s" % filename.name)
# exit()
S = NSplineSimple(points=pointsFromFile(filename),
methode=('cubic', ((2, 0, 0), (1, 0, -5))),
mode='courbure',
name='SPLINE01')
mesure = mesures(S)
debug('mesures')
for key, value in mesure.items():
exec('%s=%s' % (key, value))
exec("print '%20s = %s'%(key,value)")
if show: S.plot(titre=filename.name)
try:
i0 = S.insertPoint((0, 0))
if show and isinstance(i0, int):
S.plot(titre='insertPoint((0,0)) en position %d' % i0)
except ValueError as msg:
debug('normal', msg)
try:
i1 = S.appendPoint((2, 1.5))
if show and isinstance(i1, int):
S.plot(titre='appendPoint((2,1.5)) num=%d' % i1)
except ValueError as msg:
debug(msg)
raise
try:
i2 = S.insertPoint((-2, 0))
if show: S.plot(titre='insertPoint((2,-2)) en position %d' % i2)
except ValueError as msg:
debug(msg)
raise
try:
i3 = S.insertPoint((6, 0), len(S) / 2)
if show:
S.plot(titre='insertPoint((6,0),%d) en position %d' %
(len(S) / 2, i3))
except ValueError as msg:
debug(msg)
raise
S.removePoint(i3)
S.removePoint(i2)
S.removePoint(i1)
if show: S.plot(titre='removePoint(%d,%d,%d)' % (i3, i2, i1))
S[1] = (4, -0.1)
if show: S.plot(titre='S[1] = (4,-0.1)', show=True)
print S[1]
S._update()
pprint(S.__dict__)
dump = S.toDump()
dump['methode'] = ('cubic', 'natural')
S.load(dump)
S.name = 'SPLINE3'
if show: S.plot(titre='load(toDump())', show=True)
print S
debug(titre="Fin testModifLocales : %s" % filename.name)
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 testConstructeurs(filename, show=False):
debug(titre='testConstructeurs %s' % filename.name)
p = NSplineSimple()
debug(paragraphe='1. constructeur vide')
debug(p=p)
p = NSplineSimple(cpoints=np.zeros((1, 2)),
parent=None,
methode=('cubic', 'periodic'),
mode='rayon',
name='SPLINE1')
debug(paragraphe='2. constructeur presque vide')
print p
# for point in p.qcpolygon :
# print point
# for point in p.qdpolygon :
# print point
debug(paragraphe='3. p vide => p.cpoints=points de %s' % filename.name)
points = pointsFromFile(filename)
p.cpoints = points
if show: p.plot(titre='cpoints=pointsFromFile()')
S0 = NSplineSimple(
points=pointsFromFile(filename),
methode=('cubic', 'periodic'),
# mode='courbure',
name=filename.name)
debug(S0)
if show: S0.plot(titre=filename.name)
debug(paragraphe='4. S = NSplineSimple(**dump00) (points:%s)' %
filename.name)
dump00 = S0.toDump()
debug("dump00")
pprint(dump00)
S = NSplineSimple(**dump00)
dump01 = S.toDump()
pprint(dump01)
debug("dump00!=dump01 : %s" % dictsAreNotEqual(dump00, dump01))
debug(paragraphe='4. S1 = S0.copy() (points:%s)' % filename.name)
S = S0.copy()
dump02 = S.toDump()
debug("dump00!=dump02 : %s" % dictsAreNotEqual(dump00, dump02))
filename = Path(RUNS_DIR, 'spline.npkl')
S0.save(filename=filename)
S0.open(filename)
# debug('S0.toDump()')
# pprint(S0.toDump())
debug(S0)
debug('S0.toDump()!=dump00', dictsAreNotEqual(S0.toDump(), dump02))
if show: S0.plot(titre='open pkl')
S1 = S0.copy()
d0, d1 = dump00, S1.toDump()
debug('d0!=d1', dictsAreNotEqual(d0, d1))
if show: S1.plot(titre='copy')
debug(titre='Fin testConstructeurs %s' % filename.name)
def testMethodesGlobales(filename,show):
name = filename.name
debug(titre='testMethodesGlobales : (%s)'%name)
S = NSplineComposee()
S.open(filename)
print S
a, b = len(S)/3, 2*len(S)/3
par = '"%s"split([%d,%d])'%(name,a,b)
debug(paragraphe=par)
S.split([a,b])
debug(S)
debug(ruptures=S.cpoints[S.ruptures].tolist())
debug(cpoints=S.cpoints.tolist())
debug(epoints=S.epoints.tolist())
if show : S.plot(titre='"%s"\nsplit([%d,%d])\n'%(name,a,b)+str(S.methode))
debug(paragraphe='echantillonner() (%s)'%name)
pts = S.echantillonner()
debug(echantillon=pts.tolist())
debug(epoints=S.epoints.tolist())
debug(paragraphe='hardScale((0.2,0.2), centre=np.asarray((0,0))) (%s)'%name)
S.hardScale((0.2,0.2), centre=np.asarray((0,0)))
debug(S)
debug(cpoints=S.cpoints.tolist())
debug(epoints=S.epoints.tolist())
if show : S.plot(titre='S.hardScale((0.2,0.2),centre=(0,0))')
debug(paragraphe='translate((-1.5,0.05)) : (%s)'%name)
S.translate((-1.5,0.05))
debug(S)
if show : S.plot(titre='translate((-1.5,0.05)) : (%s)'%name)
debug(paragraphe='hardRotate(30) centre=(0,0)(%s)'%name)
debug(S)
S.hardRotate(30, centre=(0,0))
debug(cpoints=S.cpoints.tolist())
debug(epoints=S.epoints.tolist())
if show : S.plot(titre='"%s"\nhardRotate(30) centre=(0,0)'%name)
debug(paragraphe='symetriser(1) (%s)'%name)
debug(S)
S.symetriser(1)
if show : S.plot(titre='symetriser(1) (%s)'%name)
debug(paragraphe='"%s".join(1) '%name)
S.join(1)
debug(S)
debug(Ruptures=S.cpoints[S.ruptures])
debug(cpoints=S.cpoints.tolist())
debug(epoints=S.epoints.tolist())
if show : S.plot(titre='join(1)\n'+str(S.methode))
debug(paragraphe='"%s"._update() '%name)
S._update()
debug(S)
debug(cpoints=S.cpoints.tolist())
k = len(S.splines)
S.nbpd = k*[1000]
debug(dpoints=S.dpoints.tolist())
debug(epoints=S.epoints.tolist())
if show : S.plot(titre='S._update()')
debug(titre='Fin testMethodesGlobales : (%s)'%name)
def testMethodesLocales(filename, show):
name = filename.name
debug(titre='testMethodesLocales : (%s)'%name)
# debug(paragraphe='Constructeur vide')
# S0 = NSplineComposee()
# print S0
k=0
methode = [['cubic',((1, 0, 2), (1, 0, -2))], #extrados
['cubic',((1, 1, 0), (1, 1, 0))]]#intrados
debug(paragraphe='methode-%d : %s (%s)'%(k,str(methode), filename.name))
k+=1
points=pointsFromFile(filename)
_, nba = computeCordeAndNBA(points=points)
S = NSplineComposee(points=points,
ruptures=[0,nba,-1],
methode=[methode[0],methode[1]],
precision=[1000,1000],
mode=['courbure','courbure'],
nbpe=[50,40],
name='%s-%d'%(name,k)
)
# debug(S)
if show : S.plot(titre=u"'%s'\nMéthode=%s\n"%(name,str(methode)))
# debug(paragraphe=u'elaguer(eps=1, replace=True) : (%s)'%name)
S.elaguer(eps=1, replace=True)
# debug(S)
# debug(cpoints=S.cpoints.tolist())
# debug(epoints=S.epoints.tolist())
if show : S.plot(titre=u"'%s'\nLa même, élaguée"%name)
debug(paragraphe=u'(%s) removePoint(rupture[1]) '%name)
npt = S.ruptures[1]
try : S.removePoint(npt)
except NotImplementedError as msg :
debug('normal', msg)
# raise
debug(S)
pt = (0.33, 0.1)
titre=u'S.insertPoint(%s) %s'%(str(pt),name)
debug(paragraphe=titre)
try :
S.insertPoint(pt)
if show : S.plot(titre=titre)
except ValueError as msg :
print msg
raise
debug(S)
debug(cpoints=S.cpoints.tolist())
debug(epoints=S.epoints.tolist())
i = len(S)/2
titre = '"%s" : insertPoint(pt=%s,i=%d)'%(name, str(pt),i)
debug(paragraphe=titre)
S.insertPoint(pt,i)
debug(S)
debug(cpoints=S.cpoints.tolist())
debug(epoints=S.epoints.tolist())
if show : S.plot(titre=titre)
pt = (1.5,0.2)
titre = 'S[0] = %s (%s)'%(str(pt),name)
debug(paragraphe=titre)
S[0] = (1.5,0.2)
debug(S)
debug(cpoints=S.cpoints.tolist())
debug(epoints=S.epoints.tolist())
if show : S.plot(titre=titre)
titre = 'Fermeture : S[len(S)-1] = S[0] (%s)'%name
debug(paragraphe=titre)
S[len(S)-1] = S[0]
debug(S)
debug(cpoints=S.cpoints.tolist())
debug(epoints=S.epoints.tolist())
if show : S.plot(titre=titre)
for pt in((1.5,0.1),(2,2),(3,0)) :
titre = 'S.appendPoint(%s) (%s)'%(pt,name)
debug(paragraphe=titre)
S.appendPoint(pt)
debug(S)
debug(cpoints=S.cpoints.tolist())
debug(epoints=S.epoints.tolist())
if show : S.plot(titre=titre)
debug(paragraphe='S.removePoint(3) (%s)'%name)
S.removePoint(3)
# S._update()
debug(S)
debug(cpoints=S.cpoints.tolist())
debug(epoints=S.epoints.tolist())
if show : S.plot(titre='S.removePoint(3)')
debug(titre='Fin testMethodesLocales : %s'%filename.name)
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 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)
def testSaveAndOpen(filename, show=False):
name = filename.name
titre = 'testSaveAndOpen : %s' % name
debug(titre=titre)
if '.spl' in filename:
par = "Ouverture fichier (.spl) %s" % name
debug(paragraphe=par)
# with open(filename,'r') as f :
# dump = eval(f.read())
# lines = f.read()
# dump = eval(lines)
S = Profil()
try:
S.open(filename)
print S
except IndexError as msg:
rdebug('TODO:%s, %s' % (par, msg))
return #On peut pas continuer S est verolé
else:
debug(paragraphe="Ouverture fichier %s" % name)
S = Profil(
points=pointsFromFile(filename),
# methode=('cubic',((2, 0, 0), (1, 0, -5))),
mode=['courbure', 'courbure'],
precision=[3000, 3000])
debug(paragraphe="S.normalise() %s" % name)
debug(ouvertures=S.pouverture)
S.normalise()
debug(ouvertures=S.pouverture)
debug(paragraphe="pickle.dump() et pickle.load() %s" % name)
fname = Path(WORK_DIR, filename.namebase + 'Test.spl')
debug(fname)
with open(fname, 'w') as f:
cPickle.dump(S.toDump(), f)
with open(fname, 'r') as f:
dump = cPickle.load(f)
S1 = Profil(**dump)
S1.elaguer(1, True)
S1.rba = (-1, -1)
if show:
S1.plot(titre='rba=%s' % str(S1.rba))
plt.show()
dump = S.toDump()
dump1 = S1.toDump()
debug('dump==dump1 ?', dump == dump1)
pprint(dump1)
debug('S.rba = %s\n'%str(S.rba)+\
' S1.rba = %s\n'%str(S1.rba)+\
' S.erba = %s\n'%str(S.erba)+\
' S1.erba = %s\n'%str(S1.erba)+\
' S.drba = %s\n'%str(S.drba)+\
' S1.drba = %s'%str(S1.drba))
debug(titre='Fin testSaveAndOpen')
def testElagage(filename, show):
name = filename.name
debug(titre='testElagage : (%s)'%name)
k=0
for methode in (
[#moche
('cubic','natural'),
('cubic','natural')
],
[#demi-cercle
('cubic',((1, 0, 3.14), (1, 0, -3.14))),
('cubic',((1, 0, 0), (1, 0, 0)))
],
[#demi-cercle
('cubic','not-a-knot'),
('cubic','not-a-knot')
],
[
['cubic',((1, 0, 2), (1, 0, -2))], #extrados
['cubic',((1, 1, 0), (1, 1, 0))]#intrados
],
[
('cubic',((2, 0, 0), (1, 0, -5))), #extrados
('cubic',((1, 0, -5), (2, 0, 0))) #intrados
],
):
debug(paragraphe='methode-%d : %s (%s)'%(k,str(methode), filename.name))
k+=1
points=pointsFromFile(filename)
_, nba = computeCordeAndNBA(points=points)
S = NSplineComposee(points=points,
ruptures=[0,nba,-1],
methode=[methode[0],methode[1]],
precision=[1000,1000],
mode=['courbure','courbure'],
nbpe=[50,40],
name='%s-%d'%(name,k)
)
debug(S)
if show : S.plot(titre=u"'%s' avant élagage\nméthode=%s\n"%(name,str(methode)))
debug(paragraphe=u'elaguer(eps=1, replace=True) : (%s)'%name)
S.elaguer(eps=1, replace=True)
debug(S)
debug(cpoints=S.cpoints.tolist())
debug(epoints=S.epoints.tolist())
if show : S.plot(titre=u'Après élagage')
debug(titre=u'Fin testElagage : (%s)'%name)
def testElaguer(filename, show=False):
name = filename.name
debug(titre='testElaguer : %s' % name)
p = Profil(points=pointsFromFile(filename), precision=[1000, 1000])
debug(rba=p.rba)
debug("Extrados : Se'(1.0)=%s" % (p.splines[0](1.0, 1)))
debug("Intrados : Si'(0.0)=%s" % (p.splines[1](0.0, 1)))
sin0 = p.splines[0].integraleCourbure(0.01, 1, 1000)
sin1 = p.splines[1].integraleCourbure(0.01, 1, 1000)
debug('sinuosite totale avant elagage=', (sin0, sin1))
# return
p.elaguer(eps=1, replace=True)
debug(rba=p.rba)
sin10 = p.splines[0].integraleCourbure(0.01, 1, 1000)
sin11 = p.splines[1].integraleCourbure(0.01, 1, 1000)
# sin10 = p.splines[0].integraleCourbure(0.01,1,1000)
debug('sinuosite totale apres elagage=', (sin10, sin11))
debug(variation_relative_sinuosite=((sin10 - sin0) / sin0,
(sin11 - sin1) / sin1))
# debug('sinuosite totale =',p.splines[1].integraleCourbure(0.01,1,1000))
if show:
p.plot(titre='elagage')
p.plotCourbure()
plt.show()
debug(titre='Fin testElaguer')
def testElaguer(filename, trados, fonction='elaguer', show=True):
name = filename.name
debug(titre="testElaguer : %s" % name)
if fonction == 'ajuster':
msg = u"""L'élagage par "ajustement" ne marche pas, et il est très long.
Je le supprime des tests.
:TODO: voir au besoin si on peut l'améliorer"""
debug(msg)
return
def compareCourbures(s0, s1, corde, trados):
u"""s0 et s1 sont des intrados (ou des extrados), s0:original, s1:elagué
On trace les deux splines et les log des abs(courbures), mises à l'échelle pour y voir qque chose"""
s1.nbpe = s0.nbpe
titre = ' '.join(('courbures', s0.name, s1.name))
plt.title(titre)
# E = s0.epoints
_, ax = plt.subplots()
T = linspace(0, 1, 100)
# s0.echantillonner(nbpe)
D0 = s0.dpoints
C0 = s0.cpoints
spline0, = ax.plot(D0[:, 0], D0[:, 1], 'r-', lw=1)
# echantillon, = ax.plot(E[:,0], E[:,1], 'bv', lw=1)
control0, = ax.plot(C0[:, 0],
C0[:, 1],
'ro',
lw=1,
label=u'%d points contrôle' % len(C0))
courbure0 = s0.courbure(T)
courbure1 = s1.courbure(T)
minc = min(min(courbure0), min(courbure1))
maxc = max(max(abs(courbure0)), max(abs(courbure1)))
courbure0 += (1.0 + abs(minc))
courbure0 = log(courbure0)
courbure0 /= maxc
if trados == 'e':
courbure0 = courbure0[::-1]
courbure0, = ax.plot(corde * T[1:], corde * courbure0[1:])
D1 = s1.dpoints
C1 = s1.cpoints
spline1, = ax.plot(D1[:, 0], D1[:, 1], 'b-', lw=1)
control1, = ax.plot(C1[:, 0],
C1[:, 1],
'bo',
lw=1,
label=u'%d points contrôle' % len(C1))
courbure1 += (1.0 + abs(minc))
courbure1 = log(courbure1)
courbure1 /= maxc
if trados == 'e':
courbure1 = courbure1[::-1]
courbure1, = ax.plot(corde * T[1:], corde * courbure1[1:])
ax.legend(loc='upper right')
buttons = [
'control0', 'control1', 'courbure0', 'courbure1', 'spline0',
'spline1'
]
values = [True, True, True, True, True, True]
draws = [control0, control1, courbure0, courbure1, spline0, spline1]
plt.subplots_adjust(left=0.2)
plt.axis('equal')
rax = plt.axes([0.05, 0.4, 0.1, 0.15])
check = CheckButtons(rax, buttons, values)
def func(label):
if label == 'spline0':
spline0.set_visible(not spline0.get_visible())
elif label == 'spline1':
spline1.set_visible(not spline1.get_visible())
elif label == 'control0':
control0.set_visible(not control0.get_visible())
elif label == 'control1':
control1.set_visible(not control1.get_visible())
elif label == 'courbure0':
courbure0.set_visible(not courbure0.get_visible())
elif label == 'courbure1':
courbure1.set_visible(not courbure1.get_visible())
else:
draw = draws[buttons.index(label)]
draw.set_visible(not draw.get_visible())
plt.draw()
check.on_clicked(func)
if show: plt.show()
return plt
def comparePointsSpline(P, s):
u"""comparaison graphique, P famille de points s spline
On trace les projections de P sur la spline s"""
# debug(s.projection(P))
pjs = s(s.projectionObj(P)[0])
if show:
s.plot(more=([P[:, 0], P[:, 1], 'g.', 'C0'],
[pjs[:, 0], pjs[:, 1], 'y.', 'projections']))
u"""Extraction intrados et extrados, normalisation"""
points = pointsFromFile(filename)
corde, nba = -1.0, np.nan
bf = points[0]
for k, point in enumerate(points):
d = dist2(bf, point)
if d > corde: corde, nba = d, k
corde = math.sqrt(corde)
debug(corde=corde, nba=nba)
points *= (1000 / corde) #en mm
corde = 1000
if trados == 'e': #Extrados
methode = ('cubic', ((2, 0, 0), (1, 0, -corde / 2))) #extrados
c0 = points[:1 + nba]
elif trados == 'i': #intrados
methode = ('cubic', ((1, 0, -corde / 4), (2, 0, 0))) #intrados
c0 = points[nba:]
u"""Construction de la spline d'interpolation du trados"""
precision = 1000
T0 = linspace(0, 1, precision)
s0 = NSplineSimple(cpoints=c0,
precision=precision,
methode=methode,
mode='courbure')
Tc = linspace(0, 1, 100)
courb0 = s0.courbure(Tc)
u"""La spline elaguée"""
if fonction == 'elaguer':
s1, d, (n0, n1) = s0.elaguer(1, debog=show)
elif fonction == 'ajuster':
s1, d, (n0, n1) = s0.ajuster(1)
d0 = s0(T0)
d1 = s1(T0)
print u' max dist(C0, s1) = %.2e max des distances aux points de contrôle (‰) < ################' % (
d)
print u' max norme 2 D0-D1 = %.2e max des distances point à point des splines discrétisées' % max(
norm(d0 - d1, 2, axis=1))
print u' norme frobenius D0-D1 = %.2e somme des distances point à point des splines discrétisées' % norm(
d0 - d1, 'fro')
print u' norme frobenius D0-D1 = %.2e moyenne des distances point à point des splines discrétisées' % (
norm(d0 - d1, 'fro') / len(d0))
print u' nb pts contrôle : %d => %d' % (len(s0), len(s1))
# compareCourbures(s0, s1, corde, trados)
comparePointsSpline(s0.cpoints, s1)
debug(paragraphe='courbure Avant')
print courb0.tolist()
debug(paragraphe='courbure Apres')
print s1.courbure(Tc).tolist()
debug(titre="Fin testElaguer : %s" % filename.name)
def testProfil(filename, show=True):
def expose(par):
print p
print 'cpoints = asarray(%s)' % p.cpoints.tolist()
ep = p.epoints.tolist()
print 'epoints = asarray(%s)' % ep
print 'techext = asarray(%s)' % p.techext.tolist()
print 'techint = asarray(%s)' % p.techint.tolist()
if show: p.plot(titre=par, show=True)
return ep
name = filename.name
debug(titre='testProfil : %s' % name)
par = 'p = Profil()'
debug(paragraphe=par)
p = Profil()
expose(par)
par = "p = Profil(naca=['2415', 50], name=None)"
debug(paragraphe=par)
p = Profil(naca=['2415', 20], name=None)
expose(par + 'verification')
for v in p.verification():
print v
par = 'p.open("%s")' % name
debug(paragraphe=par)
try:
p.open(filename)
expose(par)
except ValueError as msg:
rdebug("TODO : %s, %s" % (par, msg))
except IndexError as msg:
rdebug("TODO : %s, %s" % (par, msg))
# exit()
par = 'Profil(points) (%s)' % name
debug(paragraphe=par)
p = Profil(cpoints=pointsFromFile(filename), name=name)
expose(par)
par = "toDump/load (%s)" % name
debug(paragraphe=par)
dump = p.toDump()
p = Profil(**dump)
expose(par)
dump1 = p.toDump()
debug(dump_NOT_equal_dump1=dictsAreNotEqual(dump, dump1))
iouv = p.iba + 5, p.iba + 10
ouv = -1.0, -10.0
par = 'p.pouverture = %s; p.iouverture = %s' % (ouv, iouv)
debug(paragraphe=par)
debug(pp=p.profparam)
p.iouverture = iouv
p.pouverture = ouv
ep0 = expose(par)
par = "constructeur recopie (%s)" % name
p = Profil(profil=p)
ep = expose(par)
debug(where(ep != ep0))
pt, i = (0.55, 0.1), 10
par = "%s : insert(%s,%d)" % (name, pt, i)
debug(paragraphe=par)
p.insertPoint(pt, i)
expose(par)
par = '%s.scaled(2.0)' % name
debug(paragraphe=par)
p = p.scaled(2.0)
expose(par)
par = '%s.hardScale((2,2))' % name
debug(paragraphe=par)
p.hardScale((2, 2))
expose(par)
par = '%s.hardRotate(30,centre=(2,2))' % name
debug(paragraphe=par)
p.hardRotate(30, centre=(2, 2))
expose(par)
par = 'p.translate((100,100)'
debug(paragraphe=par)
p.translate((100, 100))
expose(par)
# print p.verification()
par = 'normalise()'
debug(paragraphe=par)
p.normalise()
expose(par)
par = 'p[1] = (0.6,0.12)'
debug(paragraphe=par)
p[1] = (0.6, 0.12)
expose(par)
par = 'p.removePoint(1)'
debug(paragraphe=par)
p.removePoint(1)
expose(par)
# return
par = "dump('profildump.pkl') puis cPickle.load()"
debug(paragraphe=par)
p.dump(Path(RUNS_DIR, 'profildump.pkl'))
f = open(Path(RUNS_DIR, 'profildump.pkl'), 'r')
d = cPickle.load(f)
pprint(d)
p.load(d)
expose(par)
debug(p)
p.normalise()
expose('p.normalise')
debug(p)
debug(titre='Fin testprofil')
def testBlocJonc(filename, show):
# show=True
debug(titre="testBlocJonc()")
# filename = Path(VALIDATION_DIR,'blocjonc.spl')
name = filename.name
debug(paragraphe="Construction et dump '%s'"%name)
with open(filename,'r') as f :
dump = eval(f.read())['dmodel']
pprintSaufCpoints(dump)
S = NSplineSimple(**dump)
# debug(S)
if show : S.plot(numbers=['1c'])
filename = Path(VALIDATION_DIR,'blocjonc-compose.spl')
Sc = NSplineComposee()
# with open(filename,'r') as f :
# dump = eval(f.read())
# debug('dump')
# pprintSaufCpoints (dump)
Sc.open(filename)
dump['methode'] = ('ius',3)
# Sc = NSplineComposee(**dump)
# # for s in Sc.splines :
# # s.methode = 'ius',3
# # s._update()
# # Sc._update()
debug(Sc)
# exit()
# Sc.plot(numbers=['1c'])
debug(paragraphe="Split() et dump de '%s'"%name)
# Sc.split([29,38,39,40,41,50,52,54,55,63,66,74,94,105])
# debug(Sc)
if show : Sc.plot()#, numbers=['1c'])
debug("dump de '%s' apres split()"%name)
pprintSaufCpoints(Sc.toDump())
filename = Path(WORK_DIR,'blocjonc-compose-work.spl')
Sc.save(filename)
name = filename.name
debug(paragraphe="Construction NSplineComposee a partir de '%s' (=le dump apres split)"%name)
with open(filename,'r') as f :
dump = eval(f.read())
debug('>>>yeap, lecture de dump')
pprintSaufCpoints(dump)
Sc = NSplineComposee(**dump)
for i,S in enumerate(Sc.splines) :
debug("%d-eme composante de '%s'"%(i,name))
print S
if show : S.plot(titre='spline-%d'%i, numbers='c')
if show :
Sc.plot(numbers=['3c'])
Sc.plotCourbure()
debug(titre="Fin testBlocJonc()")
def testDivers1(filename, show=True):
# show=True
debug(titre="testDivers1 : %s" % filename.name)
msg = u"""
On teste les methodes NSplineSimple.projectionObj(obj) et
NSplineSimple.projection(obj).
"""
debug(msg)
cpoints = pointsFromFile(filename)[::-1]
#On recale le BA en 0,0
corde, nba = computeCordeAndNBA(cpoints)
debug(corde=corde, nba=nba, len_cpoints=len(cpoints))
cpoints = cpoints - cpoints[nba]
cpoints = cpoints[0:nba]
# cpoints = cpoints[0:nba+1]
debug(BA=cpoints[-1], BF=cpoints[0], extrados=cpoints[nba / 2])
# S0 = NSplineSimple(cpoints=cpoints, name=filename.name)
# debug(S0)
# if show : S0.plot(show=True)
########################################
# 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'}
dump = {
'classename': 'NSplineSimple',
'cpoints': cpoints,
'methode': ('cubic', 'not-a-knot'),
'mode': 'rayon',
'name': filename.name,
'nbpe': 30,
'precision': 1000,
'role': 'NSplineSimple'
}
S = NSplineSimple(**dump)
# if show : S.plot(plt)
# p1, p2, p3 = [0.0,0.25], S.barycentre[0], S.centregravite
p1, p2, p3 = [0.0, 0.25], [1.0, -0.1], [1.0, 0.1],
debug(p1=p1, p2=p2, p3=p3)
(t1, d1, n1,
m1), (t2, d2, n2,
m2), (t3, d3, n3,
m3) = S.projection(p1), S.projection(p2), S.projection(p3)
pj1, pj2, pj3 = S(t1), S(t2), S(t3)
debug(paragraphe="**** DISTANCE POINT-SPLINE discret=0 ****")
print ' message=%-20s' % m1, 'd(S,p1)=%-10.3g' % d1, 't=%-10.3g' % t1, 'nb appels a fct=%d' % n1
print ' message=%-20s' % m2, 'd(S,p2)=%-10.3g' % d2, 't=%-10.3g' % t2, 'nb appels a fct=%d' % n2
print ' message=%-20s' % m3, 'd(S,p3)=%-10.3g' % d3, 't=%-10.3g' % t3, 'nb appels a fct=%d' % n3
more = [([p1[0], pj1[0]], [p1[1],
pj1[1]], 'g-o', 'd(S,p1) : %.2g' % sqrt(d1)),
([p2[0], pj2[0]], [p2[1],
pj2[1]], 'g-o', 'd(S,p2) : %.2g' % sqrt(d2)),
([p3[0], pj3[0]], [p3[1],
pj3[1]], 'g-o', 'd(S,p3) : %.2g' % sqrt(d3))]
if show:
S.plot(more=more, titre='distance point-spline(continu)', show=True)
(t1, d1, n1, m1) = S.projection(p1, discret=100)
(t2, d2, n2, m2) = S.projection(p2, discret=100)
(t3, d3, n3, m3) = S.projection(p3, discret=100)
pj1, pj2, pj3 = S(t1), S(t2), S(t3)
debug("paragraphe=**** DISTANCE POINT-SPLINE discret=100 ****")
print ' message=%-20s' % m1, 'd(S,p1)=%-10.3g' % d1, 't=%-10.3g' % t1, 'nb appels a fct=%d' % n1
print ' message=%-20s' % m2, 'd(S,p2)=%-10.3g' % d2, 't=%-10.3g' % t2, 'nb appels a fct=%d' % n2
print ' message=%-20s' % m3, 'd(S,p3)=%-10.3g' % d3, 't=%-10.3g' % t3, 'nb appels a fct=%d' % n3
if show:
more = [([p1[0],
pj1[0]], [p1[1],
pj1[1]], 'g-o', 'd(S,p1) : %.2g' % sqrt(d1)),
([p2[0],
pj2[0]], [p2[1],
pj2[1]], 'g-o', 'd(S,p2) : %.2g' % sqrt(d2)),
([p3[0],
pj3[0]], [p3[1],
pj3[1]], 'g-o', 'd(S,p3) : %.2g' % sqrt(d3))]
S.plot(more=more, titre='distance point-spline (discret)', show=True)
T, D, N, _ = S.projectionObj(S.epoints, discret=100)
print ' S.projectionObj(S.epoints) : norm(D)=%.3g, max(D)=%.3g' % (sqrt(
sum(D)), sqrt(max(D)))
# P = asarray([p1,p2,p3])
P = (rand(5, 2) - 0.3) / 10 + S.centregravite
# debug(P.tolist())
T, D, N, _ = S.projectionObj(P, discret=1000)
S.nbpd = 1000
Pj = S(T)
debug(paragraphe='Aleatoire : S.projectionObj(P,discret=%d)' % S.nbpd,
T_D_N=zip(T, D, N))
# exit()
if show:
more = [([p[0], pj[0]], [p[1],
pj[1]], 'g-o', 'd(S,p1) : %.2g' % sqrt(d))
for p, pj, d in zip(P, Pj, D)]
S.plot(more=more, titre='distance point-spline', show=True)
debug(paragraphe=u'Elagage')
s1, d, (n0, n1) = S.elaguer(eps=1.0, debog=show)
if show:
S.plot(titre=u'avant élagage', show=False)
s1.plot(
titre=
u"Après élagage, distance=%.3g ; nb points contrôle : %d => %d" %
(d, n0, n1),
show=True)
debug(titre="Fin testDivers1 : %s" % filename.name)
return
def testEchantillonner(filename, show=False):
name = filename.name
debug(titre='testEchantillonner : %s' % name)
P = Profil(
points=pointsFromFile(filename),
# methode=('cubic',((2, 0, 0), (1, 0, -5))),
# mode=['linear'],
nbpd=[1000, 1000])
P.normalise()
P.elaguer(2, True)
P.pouverture = pam, pav = -10, -40 #en % de corde
debug(P)
touv = P.touverture #= (kam, tam), (kav,tav)
debug(touv=touv)
debug(ouverture=P.ouverture)
debug('P._getT(%.f%%)=%f' % (pam, P._getT(pam)))
debug('P._getT(%.1f%%)=%f' % (pav, P._getT(pav)))
# P.echantillonner()
if show:
P.plot(titre='echantillonage : pouv=%s, touv=%s' %
(str(P.pouverture), str(P.touverture)))
P.hardScale(2, centre=array([0, 0]))
P.hardRotate(180, centre=(0, 0))
# debug(P)
touv = P.touverture #= (kam, tam), (kav,tav)
debug(touv=touv) #,P_t=sint(t))
debug(ouverture=P.ouverture)
debug('P._getT(%.1f%%)=%f' % (pam, P._getT(pam)))
debug('P._getT(%.1f%%)=%f' % (pav, P._getT(pav)))
if show:
P.plot(titre='echantillonage : rotation 180'
) #%(str(P.pouverture),str(P.touverture)))
debug(titre='Fin testEchantillonner')
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 testProfilNormalise(filename, show):
name = filename.name
debug(titre="testProfilNormalise(%s)" % name)
debug(paragraphe="p=ProfilNormalise() (%s)" % name)
p = ProfilNormalise()
debug(paragraphe="(%s).open(filename)" % name)
p.open(filename)
debug(p)
if show: p.plot(titre=u'%s : profil original, à normaliser' % p.name)
debug(paragraphe="p=ProfilNormalise(p.toDump()) (%s)" % name)
dump = p.toDump()
p = ProfilNormalise(**dump)
debug(p)
iba = 40
iouverture = (50, 60)
par = u"p.iba=%d; p.iouverture=%s (%s)" % (iba, iouverture, name)
debug(paragraphe=par)
p.iba = iba
p.iouverture = iouverture
if show: p.plot(titre=par)
debug(p.name)
debug(epoints=p.epoints.tolist())
if show: p.plot(titre=u'%s normalisé' % p.name)
debug(normalite=p.normalite())
par = u"q = ProfilNormalise(**p.toDump()) (%s)" % (name)
debug(paragraphe=par)
dumpp = p.toDump()
q = ProfilNormalise(**dumpp)
# print p
# pprintSaufCpoints(dumpp)
# print q
debug(p_info_egale_q_info=(str(p) == str(q)))
dumpq = q.toDump()
debug(dump_p_DIFFERENT_DE_dump_q=dictsAreNotEqual(dumpp, dumpq))
# pprintSaufCpoints(dumpq)
par = u"q = ProfilNormalise(**p.toDump()) (%s)" % (name)
debug(paragraphe=par)
p = ProfilNormalise(**p.toDump())
dumpp1 = p.toDump()
debug(dumpp1_DIFFERENT_DE_dumpp=dictsAreNotEqual(dumpp, dumpp1))
debug(paragraphe=par)
par = u"p.verification (%s)" % (name)
for val in p.verification():
print val
print p.normalite()
p.normalise()
p.iouverture = p.nba + 2, p.nba + 3
print p.normalite()
# exit()
print p.cpoints.tolist()
mp = ProfilNormalise(points=pointsFrom(filename), name=name)
if show:
p.plot(show=show, titre='p = Profil(**p.toDump())')
p.plotCourbure() #(plt, titre='p = Profil(**p.toDump())')
titre = u'ProfilNormalise opérations interdites (%s)' % name
debug(titre=titre)
par = ' #hardScale'
debug(paragraphe=par)
try:
p.hardScale((2, 2))
except RuntimeError as msg:
print msg
print p.normalite()
# return
centre = asarray((7, 0))
par = '#hardRotate'
debug(paragraphe=par)
try:
mp.hardRotate(30, centre)
except RuntimeError as msg:
print msg
print p.normalite()
par = '#appendPoint'
debug(paragraphe=par)
try:
p.appendPoint((5, 10))
except RuntimeError as msg:
print msg
print p.normalite()
par = '#p[0] = (1,2)'
debug(paragraphe=par)
try:
p[0] = (1, 2)
except ValueError as msg:
print msg
print p.normalite()
par = '#insertPoint hors limites'
debug(paragraphe=par)
try:
p.insertPoint((1.1, 0.2))
except Exception as msg:
print msg
print p.normalite()
par = '#insertPoint autorise'
debug(paragraphe=par)
try:
p.insertPoint((0.5, 0.2))
except Exception as msg:
print msg
print p.normalite()
debug(titre="Fin testProfilNormalise(%s)" % name)
def testCorrectionRM(show=True):
##############################################
### debut construction exemple
##############################################
debug(titre="testCorrectionRM ")
debug()
vc = 0.25
B = asarray([[0, 0], [0.5, 0.25], [0.5, 0.8], [0, 1.1], [0, 1.7], [0.5, 2],
[0.6, 1.8], [1.5, 1.0]], float) #un S
# construction valeurs couture
SB1 = NSplineSimple(
cpoints=B,
parent=None,
# methode=('ius',1),
methode=('cubic', 'natural'),
name='B',
)
# SB1.plot(plt)
knots = SB1.knots #==B
tangentes = SB1(knots, 1) #dérivées premières
# debug(tangentes=tangentes)
normales = asarray(zip(-tangentes[:, 1], tangentes[:, 0]))
for k, normale in enumerate(normales):
normales[k] = normale / np.linalg.norm(normale)
# u = normales[0]
# debug (u[0]**2+u[1]**2)
# debug(normales=normales)
#points couture
Bc = B + vc * normales
# debug(Bc=Bc)
#spline coutures/reperes
C = NSplineSimple(cpoints=Bc,
methode=('cubic', 'natural'),
name='v.coutures')
# debug(C)
# C.plot(plt)
DC = C.dpoints
DB = SB1.dpoints
####################
## reperes mal placés
####################
nrep = len(B) #nb reperes
TR = absCurv(B, normalise=True)
R = C(TR) #repere sur spline couture, mal placés
##############################################
### fin construction exemple
### les distances dans B ne sont pas les mêmes
### que les distances dans R
##############################################
# B,R = R,B#permutation B et R
# DB,DC = DC, DB#permutation tracés
###################
lR = absCurv(R, normalise=False)[-1]
lB = absCurv(B, normalise=False)[-1]
##############################################
# correction
##############################################
SCR, T = correctionReperesMontage(B, R, 'test')
CR = SCR(T)
##############################################
#tracé
##############################################
plt.subplot(1, 2, 1)
plt.plot(DC[:, 0], DC[:, 1], 'g,')
# plt.plot(CC[:,0], CC[:,1],'r.', label='spline coutures')
plt.plot(DB[:, 0], DB[:, 1], 'b,')
# plt.plot(CB[:,0], CB[:,1],'b.', label='spline bord')
plt.suptitle(u'Cas ou longueur(R) = %.5g > %.5g = longueur(B)' % (lR, lB),
fontsize=16,
fontname='serif')
plt.plot(B[:, 0],
B[:, 1],
'b-o',
label=u'Points du bord (%d points)' % nrep)
plt.plot(R[:, 0],
R[:, 1],
'g-o',
label=u"Initialement %d repères mal placés" % nrep)
plt.plot(CR[:, 0],
CR[:, 1],
'ro',
label=u'Correction : %d repères ' % nrep)
plt.legend()
plt.axis('equal')
# if show : plt.show()
def deltaLongueur(B, R, sCR, T):
Bac, Rac, CRac = absCurv(B), absCurv(R), sCR.absCurv(T)
lB, lR, lCR = diff(Bac), diff(Rac), diff(CRac)
return lB - lR, lB - lCR
lBR, lBCR = deltaLongueur(B, R, SCR, T)
lB, lR, lCR = absCurv(B)[-1], absCurv(R)[-1], SCR.absCurv(T[-1])
plt.subplot(1, 2, 2)
plt.title(u"$\Delta$longueurs. (Longueur totale R Corrigé=%.5g)" % (lCR))
plt.plot(lBR,
'b.-',
label=u'initial : max($\delta l)=$%.2g' % max(abs(lBR)))
plt.plot(lBCR,
'r.-',
label=u'corrigé : max($\delta l)=$%.2g' % max(abs(lBCR)))
plt.plot(lBR, 'b.')
plt.plot(lBCR, 'r.')
plt.legend()
if show: plt.show()
# P7 = asarray(C(T[7]))
# C.precision*=10
# pts = C.dpoints-P7
# debug([(i, norm(p)) for i, p in enumerate(pts[5261:5565])])
# debug(C)
# 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 testCorrectionRM ")
def testConstructeurs(filename, show):
# show=True
name = filename.name
debug(titre='testConstructeurs : (%s)'%name)
debug(paragraphe='Constructeur vide')
S0 = NSplineComposee()
print S0
pprintSaufCpoints(S0.toDump())
methodes = [('cubic','not-a-knot'),('ius',3), ('cubic','natural'), ('ius',1)]
par = u"Construction spline à 4 brins %s"%str(methodes)
points=pointsFromFile(filename)
_, nba = computeCordeAndNBA(points=points)
S = NSplineComposee(points=points,
ruptures=[0,nba/2,nba, nba+nba/2,-1],
methode=methodes,
precision=4*[500],
mode=4*['courbure'],
nbpe=[50,40,40,30],
name=name
)
debug(S)
debug(cpoints = S.cpoints.tolist())
debug(epoints = S.epoints.tolist())
if show : S.plot(titre=par+name)
titre='reconstruction (%s)'%name
debug(paragraphe=titre)
# points = pointsFrom(filename)
# corde, nba = computeCordeAndNBA(points)
# S = NSplineComposee(points=points,
# ruptures=[0,nba,-1],#reference
# methode = [['cubic',((2, 0, 0), (1, 0, -10))], #extrados
# ['cubic',((1, 0, -10), (2, 0, 0))]],#intrados
# precision=[1000,1000],
# mode=['courbure','courbure'],
# nbpe=[20,40],
# name=name
# )
# debug(S)
# debug(epoints=S.epoints.tolist())
if show : S.plot(titre='Original '+str(S.methode))
debug(paragraphe='"%s" toDump()' %name)
dump0 = S.toDump()
pprintSaufCpoints(dump0)
debug(paragraphe='"%s" NSplineComposee(**dump0) '%name)
S = NSplineComposee(**dump0)
debug(S)
debug(Rupture=S.cpoints[S.ruptures].tolist())
debug(cpoints=S.cpoints.tolist())
debug(epoints=S.epoints.tolist())
if show : S.plot(titre='S = NSplineComposee(**S.toDump())')
debug(paragraphe='dump1 = S.toDump() (%s)'%name)
dump1 = S.toDump()
debug(dump0_not_equal_dump1=dictsAreNotEqual(dump0,dump1))
debug(paragraphe='S.load(dump1) (%s)'%name)
S.load(S.toDump())
R = S.cpoints[S.ruptures]
debug(S)
debug(R=R)
dump2 = S.toDump()
debug(dump1_not_equal_dump2=dictsAreNotEqual(dump1,dump2))
if show : S.plot(titre='S.load(**S.toDump())')
