def translate_src(self,idgrp):
lbl_vecx=_(u"Direction x (m)")
lbl_vecy=_(u"Direction y (m)")
lbl_vecz=_(u"Direction z (m)")
res=ui.application.getuserinput(_(u"Translation of a group of sound sources"),
"",
{ lbl_vecx : "1",
lbl_vecy : "0",
lbl_vecz : "0"
})
if res[0]:
try:
vectranslation=vec3(float(res[1][lbl_vecx]), float(res[1][lbl_vecy]), float(res[1][lbl_vecz]))
except ValueError:
print(_(u"Wrong parameters"),file=sys.stderr)
return
#on recupere le groupe des sources
srcgroup=ui.element(idgrp)
#on recupere tout les indices des sources déjà existante
srclst=srcgroup.getallelementbytype(ui.element_type.ELEMENT_TYPE_SCENE_SOURCES_SOURCE)
for src in srclst:
sourceEl=ui.element(src)
#On recupere la position de la source
pos_source = sourceEl.getpositionconfig("pos_source")
newpos=vec3(pos_source[0], pos_source[1], pos_source[2])+vectranslation
sourceEl.updatepositionconfig("pos_source",[newpos[0],newpos[1],newpos[2]])
def MakeLineRecp(recpgroupindice,
startpoint=[0, 0, 0],
quantity=1,
step=[1, 0, 0]):
"""
Crée une ligne de récepteurs ponctuels
"""
#on recupere le groupe des recepteurs
recpgroup = ui.element(recpgroupindice)
#on recupere tout les indices des récepteurs ponctuels déjà présents
oldrecplst = recpgroup.getallelementbytype(
ui.element_type.ELEMENT_TYPE_SCENE_RECEPTEURSP_RECEPTEUR)
#On construit les quantity nouveaux récepteurs ponctuels
for i in range(0, quantity):
ui.application.sendevent(recpgroup, ui.idevent.IDEVENT_NEW_RECEPTEUR_P)
#on cherche a obtenir les indices des nouveaux récepteurs ponctuels
newrecplst = recpgroup.getallelementbytype(
ui.element_type.ELEMENT_TYPE_SCENE_RECEPTEURSP_RECEPTEUR)
createdrecp = []
for recp in newrecplst:
if recp not in oldrecplst:
createdrecp.append(recp)
#on modifie la position des récepteurs ponctuels selon les pas de positions en paramètre
curpos = startpoint
for recp in createdrecp:
recpEl = ui.element(recp)
#il nous faut affecter la position du recepteur ponctuel
recpEl.updatepositionconfig("pos_recepteur", curpos)
curpos = [
curpos[0] + step[0], curpos[1] + step[1], curpos[2] + step[2]
]
def dofusion(folderwxid, path):
arraydata = GetMixedLevel(folderwxid)
SaveLevel(zip(*arraydata), path)
# raffraichie l'arbre complet
ui.application.sendevent(
ui.element(ui.element(ui.application.getrootreport()).childs()[0][0]), ui.idevent.IDEVENT_RELOAD_FOLDER
)
def MakeLineSrc(srcgroupindice,
startpoint=[0, 0, 0],
quantity=1,
step=[1, 0, 0]):
"""
Crée une ligne de source sonores
"""
#on recupere le groupe des sources
srcgroup = ui.element(srcgroupindice)
#on recupere tout les indices des sources déjà existante
oldsrclst = srcgroup.getallelementbytype(
ui.element_type.ELEMENT_TYPE_SCENE_SOURCES_SOURCE)
#On construit les quantity nouvelles sources
for i in range(0, quantity):
ui.application.sendevent(srcgroup, ui.idevent.IDEVENT_NEW_SOURCE)
#on cherche a obtenir les indices des nouvelles sources
newsrclst = srcgroup.getallelementbytype(
ui.element_type.ELEMENT_TYPE_SCENE_SOURCES_SOURCE)
createdsrc = []
for src in newsrclst:
if src not in oldsrclst:
createdsrc.append(src)
#on modifie la position des sources selon les pas de positions en paramètre
curpos = startpoint
for src in createdsrc:
srcEl = ui.element(src)
#il nous faut la position de la source
srcEl.updatepositionconfig("pos_source", curpos)
curpos = [
curpos[0] + step[0], curpos[1] + step[1], curpos[2] + step[2]
]
def translate_src(self,idgrp):
lbl_vecx=_(u"Direction x (m)")
lbl_vecy=_(u"Direction y (m)")
lbl_vecz=_(u"Direction z (m)")
res=ui.application.getuserinput(_(u"Translation of a group of sound sources"),
"",
{ lbl_vecx : "1",
lbl_vecy : "0",
lbl_vecz : "0"
})
if res[0]:
try:
vectranslation=vec3(float(res[1][lbl_vecx]), float(res[1][lbl_vecy]), float(res[1][lbl_vecz]))
except ValueError:
print(_(u"Wrong parameters"),file=sys.stderr)
return
#on recupere le groupe des sources
srcgroup=ui.element(idgrp)
#on recupere tout les indices des sources déjà existante
srclst=srcgroup.getallelementbytype(ui.element_type.ELEMENT_TYPE_SCENE_SOURCES_SOURCE)
for src in srclst:
sourceEl=ui.element(src)
#On recupere la position de la source
pos_source = sourceEl.getpositionconfig("pos_source")
newpos=vec3(pos_source[0], pos_source[1], pos_source[2])+vectranslation
sourceEl.updatepositionconfig("pos_source",[newpos[0],newpos[1],newpos[2]])
def GetMixedLevel(folderwxid):
"""
Retourne un tableau contenant le niveau sonore global et toute bande des récepteurs ponctuels d'un dossier
folderwxid identifiant wxid de l'élément dossier contenant les récepteurs ponctuels.
"""
cols=[]
#folder devient l'objet dossier
folder=ui.element(folderwxid)
#dans un tableau on place les indices des fichiers de données des récepteurs ponctuels
recplist=folder.getallelementbytype(ui.element_type.ELEMENT_TYPE_REPORT_GABE_RECP)
#Pour chaque récepteur on demande à l'application les données traitées du fichier (niveau sonore et cumuls)
for idrecp in recplist:
#recp devient l'objet ayant comme indice idrecp (entier)
recp=ui.element(idrecp)
if recp.getinfos()["name"]=="Sound level":
#on demande le calcul des paramètres sonores
ui.application.sendevent(recp,ui.idevent.IDEVENT_RECP_COMPUTE_ACOUSTIC_PARAMETERS,{"TR":"15;30", "EDT":"", "D":""})
#on recupere l'element parent (le dossier de récepteur ponctuel)
pere=ui.element(recp.getinfos()["parentid"])
#application.sendevent(pere,idevent.IDEVENT_RELOAD_FOLDER)
nomrecp=pere.getinfos()["label"]
#on recupere les données calculées
params=ui.element(pere.getelementbylibelle('Acoustic parameters'))
#on stocke dans gridspl le tableau des niveaux de pression
gridparam=ui.application.getdataarray(params)
#on ajoute la colonne
if len(cols)==0: #si le tableau de sortie est vide alors on ajoute les libellés des lignes
cols.append(list(zip(*gridparam)[0])) #libellé Freq et Global
idcol=gridparam[0].index("EDT (s)") #Changer le paramètre par celui pour lequel on veut la fusion
cols.append([nomrecp]+list(zip(*gridparam)[idcol][1:])) #1ere colonne, (0 etant le libellé des lignes) et [1:] pour sauter la premiere ligne
return cols
def GetMixedLevel(folderwxid):
"""
Retourne un tableau contenant le niveau sonore global et toute bande des récepteurs ponctuels d'un dossier
folderwxid identifiant wxid de l'élément dossier contenant les récepteurs ponctuels.
"""
cols = []
# folder devient l'objet dossier
folder = ui.element(folderwxid)
# dans un tableau on place les indices des fichiers de données des récepteurs ponctuels
recplist = folder.getallelementbytype(ui.element_type.ELEMENT_TYPE_REPORT_GABE_RECP)
# Pour chaque récepteur on demande à l'application les données traitées du fichier (niveau sonore et cumuls)
for idrecp in recplist:
# recp devient l'objet ayant comme indice idrecp (entier)
recp = ui.element(idrecp)
if recp.getinfos()["name"] == "soundpressure":
# on demande le calcul des paramètres sonores
ui.application.sendevent(
recp, ui.idevent.IDEVENT_RECP_COMPUTE_ACOUSTIC_PARAMETERS, {"TR": "15;30", "EDT": "", "D": ""}
)
# on recupere l'element parent (le dossier de récepteur ponctuel)
pere = ui.element(recp.getinfos()["parentid"])
# application.sendevent(pere,idevent.IDEVENT_RELOAD_FOLDER)
nomrecp = pere.getinfos()["label"]
# on recupere les données calculées
params = ui.element(pere.getelementbylibelle("acoustic_param"))
# on stocke dans gridspl le tableau des niveaux de pression
gridparam = ui.application.getdataarray(params)
# on ajoute la colonne
if len(cols) == 0: # si le tableau de sortie est vide alors on ajoute les libellés des lignes
cols.append(list(zip(*gridparam)[0])) # libellé Freq et Global
idcol = gridparam[0].index("EDT (s)") # Changer le paramètre par celui pour lequel on veut la fusion
cols.append(
[nomrecp] + list(zip(*gridparam)[idcol][1:])
) # 1ere colonne, (0 etant le libellé des lignes) et [1:] pour sauter la premiere ligne
return cols
def rotate_src(self, idgrp):
lbl_vecx = _(u"Vector of rotation x (m)")
lbl_vecy = _(u"Vector of rotation y (m)")
lbl_vecz = _(u"Vector of rotation z (m)")
lbl_angle = _(u"Angle (degrees)")
lbl_rotation_posx = _(u"Rotation center x (m)")
lbl_rotation_posy = _(u"Rotation center y (m)")
lbl_rotation_posz = _(u"Rotation center z (m)")
##Evaluation du centre de rotation
#on recupere le groupe des sources
srcgroup = ui.element(idgrp)
#on recupere tout les indices des sources déjà existante
srclst = srcgroup.getallelementbytype(
ui.element_type.ELEMENT_TYPE_SCENE_SOURCES_SOURCE)
centregroup = vec3()
for src in srclst:
sourceEl = ui.element(src)
#On recupere la position de la source
pos = sourceEl.getpositionconfig("pos_source")
centregroup += vec3(pos[0], pos[1], pos[2])
centregroup /= len(srclst)
res = ui.application.getuserinput(
_(u"Rotation of a group of sound sources"), "", {
lbl_vecx: "0",
lbl_vecy: "0",
lbl_vecz: "1",
lbl_angle: "90",
lbl_rotation_posx: str(centregroup[0]),
lbl_rotation_posy: str(centregroup[1]),
lbl_rotation_posz: str(centregroup[2])
})
if res[0]:
vecrotation = vec3()
try:
vecrotation = vec3(float(res[1][lbl_vecx]),
float(res[1][lbl_vecy]),
float(res[1][lbl_vecz]))
anglerotation = float(res[1][lbl_angle])
centregroup = vec3(float(res[1][lbl_rotation_posx]),
float(res[1][lbl_rotation_posy]),
float(res[1][lbl_rotation_posz]))
except:
print(_(u"Wrong parameters"), file=sys.stderr)
return
#on recupere le groupe des sources
srcgroup = ui.element(idgrp)
#on recupere tout les indices des sources déjà existante
srclst = srcgroup.getallelementbytype(
ui.element_type.ELEMENT_TYPE_SCENE_SOURCES_SOURCE)
for src in srclst:
sourceEl = ui.element(src)
pos_source = sourceEl.getpositionconfig("pos_source")
rotatedpos = vec3(pos_source[0], pos_source[1],
pos_source[2]) - centregroup
rotatedpos = rotatedpos.Rotation(
vecrotation, math.radians(anglerotation)) + centregroup
sourceEl.updatepositionconfig(
"pos_source",
[rotatedpos[0], rotatedpos[1], rotatedpos[2]])
def rotate(self,idgrp):
lbl_vec=_(u"Vector of rotation (m)")
lbl_angle=_(u"Angle of rotation (degrees)")
lbl_rotation_pos=_(u"Rotation center (m)")
#on recupere le groupe des rp
rpgroup=ui.element(idgrp)
#on recupere tout les indices des rp déjà existante
rplst=rpgroup.getallelementbytype(ui.element_type.ELEMENT_TYPE_SCENE_RECEPTEURSP_RECEPTEUR)
centregroup=vec3()
for rp in rplst:
rpEl=ui.element(rp)
#On recupere la position du récepteur ponctuel
centregroup+=vec3(rpEl.getpositionconfig("pos_recepteur"))
centregroup/=len(rplst)
res=ui.application.getuserinput(_(u"Rotation of a group of receivers"),
"",
{ lbl_vec : "[0.,0.,1.]",
lbl_angle : "90",
lbl_rotation_pos : str(centregroup)
})
if res[0]:
try:
vecrotation=vec3(eval(res[1][lbl_vec]))
anglerotation=float(res[1][lbl_angle])
centregroup=vec3(eval(res[1][lbl_rotation_pos]))
except:
print(_(u"Wrong parameters"),file=sys.stderr)
return
for rp in rplst:
rpEl=ui.element(rp)
rotatedpos=vec3(rpEl.getpositionconfig("pos_recepteur"))-centregroup
rotatedpos=rotatedpos.rotate(vecrotation,math.radians(anglerotation))+centregroup
rpEl.updatepositionconfig("pos_recepteur",[rotatedpos.x,rotatedpos.y,rotatedpos.z])
def translate(self,idgrp):
lbl_vecx=_(u"Direction x (m)")
lbl_vecy=_(u"Direction y (m)")
lbl_vecz=_(u"Direction z (m)")
res=ui.application.getuserinput(_(u"Translation of a group of receivers"),
_(u"Please enter the coordinates of the translation vector"),
{ lbl_vecx : "1.",
lbl_vecy : "0.",
lbl_vecz : "0.",
})
if res[0]:
try:
vectranslation=vec3(float(res[1][lbl_vecx]),float(res[1][lbl_vecy]),float(res[1][lbl_vecz]))
except:
print(_(u"Wrong parameters"),file=sys.stderr)
return
#on recupere le groupe des rp
rpgroup=ui.element(idgrp)
#on recupere tout les indices des rp déjà existante
rplst=rpgroup.getallelementbytype(ui.element_type.ELEMENT_TYPE_SCENE_RECEPTEURSP_RECEPTEUR)
for rp in rplst:
rpEl=ui.element(rp)
#On recupere la position du rp
posrecp = rpEl.getpositionconfig("pos_recepteur")
newpos=vec3(posrecp[0], posrecp[1], posrecp[2])+vectranslation
rpEl.updatepositionconfig("pos_recepteur",[newpos[0],newpos[1],newpos[2]])
def GetCurrentProjectPath():
projconfel = ui.element(
ui.element(ui.application.getrootscene()).getelementbytype(
ui.element_type.ELEMENT_TYPE_SCENE_PROJET_CONFIGURATION
)
)
return projconfel.getstringconfig("urlsave")
def dofusion(folderwxid, path):
arraydata = GetMixedLevel(folderwxid)
SaveLevel(zip(*arraydata), path)
#raffraichie l'arbre complet
ui.application.sendevent(
ui.element(ui.element(ui.application.getrootreport()).childs()[0][0]),
ui.idevent.IDEVENT_RELOAD_FOLDER)
def AskUserToSelectASource(self):
#Il faut faire la liste des libellés de toutes les sources
rootscene = ui.element(ui.application.getrootscene())
sourclst_ids = rootscene.getallelementbytype(
ui.element_type.ELEMENT_TYPE_SCENE_SOURCES_SOURCE)
dict_src = {}
for sourceid in sourclst_ids:
src = ui.element(sourceid)
dict_src[src.getinfos()["name"]] = sourceid
srcLst = dict_src.keys()
srcLst.sort()
srcsellabel = _(u"Source name")
dialog_res = ui.application.getuserinput(
_(u"Source selection"), _(u"Please choose the source:"),
{srcsellabel: srcLst})
if (dialog_res[0] == 1 and srcsellabel in dialog_res[1].keys()):
selected_sourcename = dialog_res[1][srcsellabel]
if selected_sourcename in dict_src.keys():
selected_sourceid = dict_src[selected_sourcename]
return selected_sourceid
else:
return -1
else:
return -1
def modified(self,idelmodified):
#Le mode de calcul stationnaire n'a pas besoin des paramètres de pas de temps ni de durée
if ui.element(idelmodified).getinfos()["name"]=="solver_mode":
#le mode de calcul a été modifié par l'utilisateur
elconf=ui.element(self.getelementbytype(ui.element_type.ELEMENT_TYPE_CORE_CORE_CONFIG))
is_temporel=(elconf.getlistconfig("solver_mode")==0)
elconf.setreadonlyconfig("duree_simulation",not is_temporel)
elconf.setreadonlyconfig("pasdetemps",not is_temporel)
ui.element.modified(self,idelmodified)
def __init__(self,idel):
#Initialisation de l'élément
ui.element.__init__(self,idel)
if not self.hasproperty("exeName"): #La propriété n'existe pas s'il s'agit d'un nouveau projet, elle existe si le projet est chargé
#Création des paramètres du maillage tetgen, ne pas le faire si le calcul n'a pas besoin de maillage tétraèdrique
self.appendfilsbytype(ui.element_type.ELEMENT_TYPE_CORE_CORE_CONFMAILLAGE)
#Ajout de la sélection des bandes de fréquences, ne pas le faire si c'est inutile
self.appendfilsbytype(ui.element_type.ELEMENT_TYPE_CORE_CORE_BFREQSELECTION)
#Ajout du noeud de configuration, qui contient par défaut les propriétés de pas de temps et de durée de simulation
coreconf=ui.element(self.appendfilsbytype(ui.element_type.ELEMENT_TYPE_CORE_CORE_CONFIG))
####
#Ces propriétés sont nécessaire pour que I-SIMPA connaisse les fichiers relatifs au code de calcul
#Nom et format du modèle 3D
ui.element(self.appendpropertytext("modelName","","mesh.cbin",True,True)).hide()
#Nom du maillage tétraèdrique
ui.element(self.appendpropertytext("tetrameshFileName","","tetramesh.mbin",True,True)).hide()
#Nom et type (exe,py ou pyc) du fichier executable
ui.element(self.appendpropertytext("exeName","","user_core")).hide()
ui.element(self.appendpropertytext("corePath","","usercore\\")).hide()
#Création des paramètres de calculs
coreconf.appendpropertylist("solver_mode",_("Mode de calcul"),[[_("Temporel"),_("Stationnaire")],[0,1]],0,False,1,True)
else:
#Chargement d'un projet existant
pass
def __init__(self,idel):
ui.element.__init__(self,idel)
#Ce code de calcul a surement des propriétés
#Il faut les créer(nouveau projet) ou les mettre à jour (chargement) ici
if not self.hasproperty("exeName"): #Nouveau projet
#Création des paramètre du maillage tetgen
self.appendfilsbytype(ui.element_type.ELEMENT_TYPE_CORE_CORE_CONFMAILLAGE)
self.appendfilsbytype(ui.element_type.ELEMENT_TYPE_CORE_CORE_BFREQSELECTION)
coreconf=ui.element(self.appendfilsbytype(ui.element_type.ELEMENT_TYPE_CORE_CORE_CONFIG))
ui.element(self.appendpropertytext("modelName","","mesh.cbin",True,True)).hide()
ui.element(self.appendpropertytext("tetrameshFileName","","tetramesh.mbin",True,True)).hide()
ui.element(self.appendpropertytext("exeName","","md.py")).hide()
ui.element(self.appendpropertytext("corePath","","md\\")).hide()
#Création des paramètres de calculs
coreconf.appendpropertylist("solver_mode","Mode de calcul",[["Temporel","Stationnaire"],[0,1]],0,False,1,True)
coreconf.appendpropertybool("with_direct_sound","Fusion avec le champ direct",True,True)
_("Fusion avec le champ direct")
_("Mode de calcul")
_("Temporel")
_("Stationnaire")
else:
#Chargement d'un projet existant
if self.getstringconfig("corePath")=="md_trans\\":
self.updatestringconfig("corePath","md\\")
def getmenu(self,typeel,idel,menu):
#Si le pere de l'element se nomme SPPS
el=ui.element(idel)
infos=el.getinfos()
if infos["parentid"]>0:
parent=ui.element(infos["parentid"])
if parent.getinfos()["label"]=="SPPS" or parent.getinfos()["label"]==u"Diffusion model":
menu.insert(0,(_("Make report"),self.MakeReportEventId))
return True
else:
return False
return False
def onmovetoothergroup(self,elid):
#On stocke les groupes de surfaces du projet
rootscene=ui.element(ui.application.getrootscene())
rootgroups=ui.element(rootscene.getelementbytype(ui.element_type.ELEMENT_TYPE_SCENE_GROUPESURFACES))
maingroupchildlist=rootgroups.childs()
listgroups=[(elname,idelement) for idelement,eltype,elname in maingroupchildlist]
input_lbl=_(u"Label")
input_values=[ elname for elname,idelement in listgroups]
dialog_res=ui.application.getuserinput(_(u"Move faces"),_(u"(Please select the group of destination:"),{ input_lbl : input_values})
if dialog_res[0]==True:
ideldest=listgroups[input_values.index(dialog_res[1][input_lbl])][1]
ui.application.dropselectionto(ui.element(ideldest))
def GetMixedLevel(folderwxid):
"""
Retourne un tableau contenant le niveau sonore global et toute bande des récepteurs ponctuels d'un dossier
folderwxid identifiant wxid de l'élément dossier contenant les récepteurs ponctuels.
"""
i_cols=[]
myfrequency_labels=[]
#folder devient l'objet dossier
recplist=[]
folder=ui.element(folderwxid)
# retrieve computation result main folder location
folderpath = ui.e_file(folder.getinfos()["parentid"]).buildfullpath()
recpPosition = extractReceiverPositionFromXml(os.path.join(folderpath, 'config.xml'))
for child in folder.childs():
if child[1]==ui.element_type.ELEMENT_TYPE_REPORT_FOLDER:
recplist.append(child[0])
#Pour chaque récepteur on demande a l'application les données traitées du fichier ( niveau sonore et cumuls )
intensityElements = {}
for idrecp in recplist:
#recp devient l'objet ayant comme indice idrecp (entier)
parent=ui.element(idrecp)
#application.sendevent(pere,idevent.IDEVENT_RELOAD_FOLDER)
receiverName=parent.getinfos()["label"]
#on recupere les données calculées
elid = parent.getelementbylibelle('Punctual receiver intensity')
if elid != -1:
intensity=ui.element(elid)
intensityElements[receiverName] = intensity
for receiverInfo in recpPosition:
receiverName, rx, ry, rz = receiverInfo
if receiverName in intensityElements:
intensity = intensityElements[receiverName]
#on stocke dans gridspl le tableau des niveaux de pression
gridparam=ui.application.getdataarray(intensity)
values=gridparam[-1][1:]
#retrieve the last row
if len(myfrequency_labels)==0:
myfrequency_labels=list(gridparam[0][1:])
myfrequency_labels.insert(0, "z")
myfrequency_labels.insert(0, "y")
myfrequency_labels.insert(0, "x")
myfrequency_labels.insert(0, "")
myReceiverRow = [receiverName,rx,ry,rz]
for idxyz in range(len(values)):
I=values[idxyz]*1
myReceiverRow.append(I)
i_cols.append(myReceiverRow)
i_cols.insert(0,myfrequency_labels)
return i_cols
def GetMixedLevel(folderwxid):
"""
Retourne un tableau contenant le niveau sonore global et toute bande des récepteurs ponctuels d'un dossier
folderwxid identifiant wxid de l'élément dossier contenant les récepteurs ponctuels.
"""
i_cols = []
myfrequency_labels = []
#folder devient l'objet dossier
recplist = []
folder = ui.element(folderwxid)
# retrieve computation result main folder location
folderpath = ui.e_file(folder.getinfos()["parentid"]).buildfullpath()
recpPosition = extractReceiverPositionFromXml(
os.path.join(folderpath, 'config.xml'))
for child in folder.childs():
if child[1] == ui.element_type.ELEMENT_TYPE_REPORT_FOLDER:
recplist.append(child[0])
#Pour chaque récepteur on demande a l'application les données traitées du fichier ( niveau sonore et cumuls )
intensityElements = {}
for idrecp in recplist:
#recp devient l'objet ayant comme indice idrecp (entier)
parent = ui.element(idrecp)
#application.sendevent(pere,idevent.IDEVENT_RELOAD_FOLDER)
receiverName = parent.getinfos()["label"]
#on recupere les données calculées
elid = parent.getelementbylibelle('Punctual receiver intensity')
if elid != -1:
intensity = ui.element(elid)
intensityElements[receiverName] = intensity
for receiverInfo in recpPosition:
receiverName, rx, ry, rz = receiverInfo
if receiverName in intensityElements:
intensity = intensityElements[receiverName]
#on stocke dans gridspl le tableau des niveaux de pression
gridparam = ui.application.getdataarray(intensity)
values = gridparam[-1][1:]
#retrieve the last row
if len(myfrequency_labels) == 0:
myfrequency_labels = list(gridparam[0][1:])
myfrequency_labels.insert(0, "z")
myfrequency_labels.insert(0, "y")
myfrequency_labels.insert(0, "x")
myfrequency_labels.insert(0, "")
myReceiverRow = [receiverName, rx, ry, rz]
for idxyz in range(len(values)):
I = values[idxyz] * 1
myReceiverRow.append(I)
i_cols.append(myReceiverRow)
i_cols.insert(0, myfrequency_labels)
return i_cols
def GetPonctualReceiversData(folderwxid):
"""
Retourne un dictionnaire contenant les données des récepteurs ponctuels
Structure
{ "Libellé du récepteur ponctuel"
: { "sound_level" : [],
"rt30" : [],
"edt" : []
}
}
"""
data = {}
#folder devient l'objet dossier
folder = ui.element(folderwxid)
#dans un tableau on place les indices des fichiers de données des récepteurs ponctuels
recplist = folder.getallelementbytype(
ui.element_type.ELEMENT_TYPE_REPORT_GABE_RECP)
#Pour chaque récepteur on demande a l'application les données traitées du fichier ( niveau sonore et cumuls )
for idrecp in recplist:
#recp devient l'objet ayant comme indice idrecp (entier)
recp = ui.element(idrecp)
recpinfos = recp.getinfos()
if recpinfos["name"] == "Sound level":
recpdata = {}
#on recupere l'element parent (le dossier de récepteur ponctuel)
pere = ui.element(recp.getinfos()["parentid"])
#on demande le calcul des paramètres sonores
if pere.getelementbylibelle('acoustic_param') == -1:
ui.application.sendevent(
recp, ui.idevent.IDEVENT_RECP_COMPUTE_ACOUSTIC_PARAMETERS,
{"TR": "30"})
#application.sendevent(pere,idevent.IDEVENT_RELOAD_FOLDER)
nomrecp = pere.getinfos()["label"]
#on recupere les données calculées
params = ui.element(
pere.getelementbylibelle('Acoustic parameters'))
#on stocke dans gridspl le tableau des niveaux de pression
gridparam = ui.application.getdataarray(params)
rotated = zip(*gridparam)
labels = gridparam[0]
tr30index = labels.index(ui._("TR-%g (s)") % (30))
edt_index = labels.index(ui._("EDT (s)"))
#on ajoute les données
recpdata["sound_level"] = ui.application.getdataarray(recp)
recpdata["rt30"] = map(ReplaceNanByZero, rotated[tr30index])
recpdata["edt"] = map(ReplaceNanByZero, rotated[edt_index])
data[nomrecp] = recpdata
return data
def GetMixedLevel(folderwxid):
"""
Retourne un tableau contenant le niveau sonore global et toute bande des récepteurs ponctuels d'un dossier
folderwxid identifiant wxid de l'élément dossier contenant les récepteurs ponctuels.
"""
i_cols = [] # Initialisation
myfrequency_labels = [] # Initialisation
# folder devient l'objet dossier
recplist = [] # Initialisation
folder = ui.element(folderwxid)
# retrieve computation result main folder location
folderpath = ui.e_file(folder.getinfos()["parentid"]).buildfullpath()
recpPosition = extractReceiverPositionFromXml(os.path.join(folderpath, 'config.xml'))
for child in folder.childs():
if child[1] == ui.element_type.ELEMENT_TYPE_REPORT_FOLDER:
recplist.append(child[0]) # On incrémente le vecteur "recplist" avec le nombre de récepteurs
# Pour chaque récepteur on demande a l'application les données traitées du fichier ( niveau sonore et cumuls )
splElements = {}
for idrecp in recplist: # On regarde pour un récepteur donné
# recp devient l'objet ayant comme indice idrecp (entier)
parent = ui.element(idrecp) # On sélectionne la ligne correspondantau récepteur "Ri"
# application.sendevent(pere,idevent.IDEVENT_RELOAD_FOLDER)
receiverName = parent.getinfos()[u"label"] # Dans "receiverName" nous plaçons le nom du récepteur "Ri"
# on recupere les données calculées
idel = parent.getelementbylibelle("Sound level")
if idel != -1:
splElement = ui.element(idel)
splElements[receiverName] = splElement
for receiverInfo in recpPosition:
receiverName, rx, ry, rz = receiverInfo
if receiverName in splElements:
splElement = splElements[receiverName]
# on stocke dans gridspl le tableau des niveaux de pression
fullsplgrid = zip(*ui.application.getdataarray(splElement))
splgrid = fullsplgrid[-1][1:-1]
# retrieve the last row
if len(myfrequency_labels) == 0:
myfrequency_labels = list(fullsplgrid[0][1:-1])
myfrequency_labels.insert(0, "z")
myfrequency_labels.insert(0, "y")
myfrequency_labels.insert(0, "x")
myfrequency_labels.insert(0, "")
myWRow = [receiverName,rx,ry,rz]
for idfreq in range(len(splgrid)):
w = (p0 * 10 ** (splgrid[idfreq] / 10.)) / (
rho * cel ** 2) # Calcul de la densité pour chaque bande de fréquence
myWRow.append(w) # Alimentation d'un vecteur densité
i_cols.append(myWRow)
i_cols.insert(0, myfrequency_labels) # Insertion de la fréquence
return i_cols
def OnSourceLabelChange(self,idsource):
if idsource == self.srcid:
newlblsrc=ui.element(idsource).getinfos()["name"]
if newlblsrc!=self.srclbl:
self.srclbl=newlblsrc
try:
receiver=ui.element(self.receiverid)
if not self.isPositionTracker:
dir=ui.element(receiver.getelementbylibelle("direction_dot"))
else:
dir=ui.element(receiver.getelementbylibelle("pos_recepteur"))
dir.updatestringconfig("linkedsource",ui.element(idsource).getinfos()["name"])
except:
self.sourceposid=-1 #le recepteur n'existe plus
def align_on_same_point(self,idel):
lbl_topt=_(u"Orienter vers [x,y,z]")
res=ui.application.getuserinput(_(u"Orienter un groupe de récepteur vers un point dans l'espace."),
_(u"Veuillez saisir les coordonnées du point d'orientation."),
{ lbl_topt : "[0.,0.,0.]"
})
if res[0]:
grprecp=ui.element(idel)
recplst=grprecp.getallelementbytype(ui.element_type.ELEMENT_TYPE_SCENE_RECEPTEURSP_RECEPTEUR)
topt=eval(res[1][lbl_topt])
for recpid in recplst:
recp=ui.element(recpid)
recp.updatepositionconfig("direction_dot",topt)
def OnSourceLabelChange(self,idsource):
if idsource == self.srcid:
newlblsrc=ui.element(idsource).getinfos()["name"]
if newlblsrc!=self.srclbl:
self.srclbl=newlblsrc
try:
receiver=ui.element(self.receiverid)
if not self.isPositionTracker:
dir=ui.element(receiver.getelementbylibelle("direction_dot"))
else:
dir=ui.element(receiver.getelementbylibelle("pos_recepteur"))
dir.updatestringconfig("linkedsource",ui.element(idsource).getinfos()["name"])
except:
self.sourceposid=-1 #le recepteur n'existe plus
def align_on_same_point(self,idel):
lbl_topt=_(u"Orient to position [x,y,z]")
res=ui.application.getuserinput(_(u"Orient a group of receivers to a point"),
_(u"Please enter the coordinates of the orientation point"),
{ lbl_topt : "[0.,0.,0.]"
})
if res[0]:
grprecp=ui.element(idel)
recplst=grprecp.getallelementbytype(ui.element_type.ELEMENT_TYPE_SCENE_RECEPTEURSP_RECEPTEUR)
topt=eval(res[1][lbl_topt])
for recpid in recplst:
recp=ui.element(recpid)
recp.updatepositionconfig("direction_dot",topt)
def rotate_src(self,idgrp):
lbl_vecx=_(u"Vector of rotation x (m)")
lbl_vecy=_(u"Vector of rotation y (m)")
lbl_vecz=_(u"Vector of rotation z (m)")
lbl_angle=_(u"Angle (degrees)")
lbl_rotation_posx=_(u"Rotation center x (m)")
lbl_rotation_posy=_(u"Rotation center y (m)")
lbl_rotation_posz=_(u"Rotation center z (m)")
##Evaluation du centre de rotation
#on recupere le groupe des sources
srcgroup=ui.element(idgrp)
#on recupere tout les indices des sources déjà existante
srclst=srcgroup.getallelementbytype(ui.element_type.ELEMENT_TYPE_SCENE_SOURCES_SOURCE)
centregroup=vec3()
for src in srclst:
sourceEl=ui.element(src)
#On recupere la position de la source
pos = sourceEl.getpositionconfig("pos_source")
centregroup+=vec3(pos[0], pos[1], pos[2])
centregroup/=len(srclst)
res=ui.application.getuserinput(_(u"Rotation of a group of sound sources"),
"",
{ lbl_vecx : "0",
lbl_vecy : "0",
lbl_vecz : "1",
lbl_angle : "90",
lbl_rotation_posx : str(centregroup[0]),
lbl_rotation_posy : str(centregroup[1]),
lbl_rotation_posz : str(centregroup[2])
})
if res[0]:
vecrotation = vec3()
try:
vecrotation=vec3(float(res[1][lbl_vecx]), float(res[1][lbl_vecy]), float(res[1][lbl_vecz]))
anglerotation=float(res[1][lbl_angle])
centregroup=vec3(float(res[1][lbl_rotation_posx]), float(res[1][lbl_rotation_posy]), float(res[1][lbl_rotation_posz]))
except:
print(_(u"Wrong parameters"),file=sys.stderr)
return
#on recupere le groupe des sources
srcgroup=ui.element(idgrp)
#on recupere tout les indices des sources déjà existante
srclst=srcgroup.getallelementbytype(ui.element_type.ELEMENT_TYPE_SCENE_SOURCES_SOURCE)
for src in srclst:
sourceEl=ui.element(src)
pos_source = sourceEl.getpositionconfig("pos_source")
rotatedpos=vec3(pos_source[0], pos_source[1], pos_source[2])-centregroup
rotatedpos=rotatedpos.Rotation(vecrotation,math.radians(anglerotation))+centregroup
sourceEl.updatepositionconfig("pos_source",[rotatedpos[0],rotatedpos[1], rotatedpos[2]])
def OnSourcePositionChange(self,idsourcepos):
if(self.sourceposid==idsourcepos):
try:
source=ui.element(ui.element(idsourcepos).getinfos()["parentid"])
recp=ui.element(self.receiverid)
if not self.isPositionTracker:
recp.updatepositionconfig("direction_dot",source.getpositionconfig("pos_source"))
else:
recp_pos=recp.getpositionconfig("pos_recepteur")
new_source_pos=source.getpositionconfig("pos_source")
new_recppos=[recp_pos[i]-self.old_src_pos[i]+new_source_pos[i] for i in range(3)]
recp.updatepositionconfig("pos_recepteur",new_recppos)
self.old_src_pos=new_source_pos
except:
self.sourceposid=-1 #le recepteur n'existe plus
def LinkSourcePositionWithReceiverOrientation(sourceId,ReceiverId):
#Il faut ajouter un indice dans l'element de propriete de direction du recepteur ponctuel afin de retrouver la source au prochaine chargement du projet
receiver=ui.element(ReceiverId)
source=ui.element(sourceId)
posel=ui.element(receiver.getelementbylibelle("direction_dot"))
if(posel.hasproperty("linkedsource")):
#Mettre a jour la propriete
posel.updatestringconfig("linkedsource",source.getinfos()["name"])
else:
#Ajouter la propriete
ui.element(posel.appendpropertytext("linkedsource","linkedsource",source.getinfos()["name"])).hide()
if not SourcePosTrackerLst.has_key(ReceiverId):
SourcePosTrackerLst[ReceiverId]=PositionUpdater(ReceiverId)
else:
SourcePosTrackerLst[ReceiverId].UpdateLinker()
def LinkSourcePositionWithReceiverOrientation(sourceId,ReceiverId):
#Il faut ajouter un indice dans l'element de propriete de direction du recepteur ponctuel afin de retrouver la source au prochaine chargement du projet
receiver=ui.element(ReceiverId)
source=ui.element(sourceId)
posel=ui.element(receiver.getelementbylibelle("direction_dot"))
if(posel.hasproperty("linkedsource")):
#Mettre a jour la propriete
posel.updatestringconfig("linkedsource",source.getinfos()["name"])
else:
#Ajouter la propriete
ui.element(posel.appendpropertytext("linkedsource","linkedsource",source.getinfos()["name"])).hide()
if not SourcePosTrackerLst.has_key(ReceiverId):
SourcePosTrackerLst[ReceiverId]=PositionUpdater(ReceiverId)
else:
SourcePosTrackerLst[ReceiverId].UpdateLinker()
def OnSourcePositionChange(self,idsourcepos):
if(self.sourceposid==idsourcepos):
try:
source=ui.element(ui.element(idsourcepos).getinfos()["parentid"])
recp=ui.element(self.receiverid)
if not self.isPositionTracker:
recp.updatepositionconfig("direction_dot",source.getpositionconfig("pos_source"))
else:
recp_pos=recp.getpositionconfig("pos_recepteur")
new_source_pos=source.getpositionconfig("pos_source")
new_recppos=[recp_pos[i]-self.old_src_pos[i]+new_source_pos[i] for i in range(3)]
recp.updatepositionconfig("pos_recepteur",new_recppos)
self.old_src_pos=new_source_pos
except:
self.sourceposid=-1 #le recepteur n'existe plus
def LinkSourcePositionWithReceiverPosition(sourceId,ReceiverId):
#Il faut ajouter les coordonnées X,Y,Z de décalage avec la source
#Ainsi que le nom de la source dans cette propriété
receiver=ui.element(ReceiverId)
source=ui.element(sourceId)
posel=ui.element(receiver.getelementbylibelle("pos_recepteur"))
if(posel.hasproperty("linkedsource")):
#Mettre a jour la propriete
posel.updatestringconfig("linkedsource",source.getinfos()["name"])
else:
#Ajouter la propriete
ui.element(posel.appendpropertytext("linkedsource","linkedsource",source.getinfos()["name"])).hide()
if not SourcePosToReceiverPosTrackerLst.has_key(ReceiverId):
SourcePosToReceiverPosTrackerLst[ReceiverId]=PositionUpdater(ReceiverId,True)
else:
SourcePosToReceiverPosTrackerLst[ReceiverId].UpdateLinker()
def align_on_same_point(self, idel):
lbl_topt = _(u"Orienter vers [x,y,z]")
res = ui.application.getuserinput(
_(u"Orienter un groupe de récepteur vers un point dans l'espace."
),
_(u"Veuillez saisir les coordonnées du point d'orientation."),
{lbl_topt: "[0.,0.,0.]"})
if res[0]:
grprecp = ui.element(idel)
recplst = grprecp.getallelementbytype(
ui.element_type.ELEMENT_TYPE_SCENE_RECEPTEURSP_RECEPTEUR)
topt = eval(res[1][lbl_topt])
for recpid in recplst:
recp = ui.element(recpid)
recp.updatepositionconfig("direction_dot", topt)
def UnlinkReceiverDir(self, idel):
positionel = ui.element(idel)
ReceiverId = positionel.getinfos()["parentid"]
if SourcePosTrackerLst.has_key(ReceiverId):
positionel.deleteelementbyxmlid(
positionel.getelementbylibelle("linkedsource"))
SourcePosTrackerLst[ReceiverId].Unlink()
def getmenu(self,typeel,idel,menu):
#On ajoute la fonction seulement si il s'agit de la position d'un récepteur ponctuel
infoEl=ui.element(idel).getinfos()
infoParent=ui.element(infoEl["parentid"]).getinfos()
if infoParent["typeElement"]==ui.element_type.ELEMENT_TYPE_SCENE_RECEPTEURSP_RECEPTEUR:
if infoEl["name"]==u"direction_dot":
menu.insert(1,(_(u"Link to a source"),self.linkWithSourcePositionEventId))
if ui.element(idel).hasproperty("linkedsource"):
menu.insert(1,(_(u"Delete the link with the source"),self.unlinkReceiverDirEventId))
return True
elif infoEl["name"]==u"pos_recepteur":
menu.insert(1,(_(u"Please choose the source:"),self.linkPositionWithSourcePositionEventId))
#todo tester si la position du récepteur est déjà lié a une source
return True
return False
def getmenu(self,typeel,idel,menu):
#On ajoute la fonction seulement si il s'agit de la position d'un récepteur ponctuel
infoEl=ui.element(idel).getinfos()
infoParent=ui.element(infoEl["parentid"]).getinfos()
if infoParent["typeElement"]==ui.element_type.ELEMENT_TYPE_SCENE_RECEPTEURSP_RECEPTEUR:
if infoEl["name"]==u"direction_dot":
menu.insert(1,(_(u"Link to a source:"),self.linkWithSourcePositionEventId))
if ui.element(idel).hasproperty("linkedsource"):
menu.insert(1,(_(u"Delete the link with the source"),self.unlinkReceiverDirEventId))
return True
elif infoEl["name"]==u"pos_recepteur":
menu.insert(1,(_(u"Please choose the source:"),self.linkPositionWithSourcePositionEventId))
#todo tester si la position du récepteur est déjà lié a une source
return True
return False
def GetPonctualReceiversData(folderwxid):
"""
Retourne un dictionnaire contenant les données des récepteurs ponctuels
Structure
{ "Libellé du récepteur ponctuel"
: { "sound_level" : [],
"rt30" : [],
"edt" : []
}
}
"""
data={}
#folder devient l'objet dossier
folder=ui.element(folderwxid)
#dans un tableau on place les indices des fichiers de données des récepteurs ponctuels
recplist=folder.getallelementbytype(ui.element_type.ELEMENT_TYPE_REPORT_GABE_RECP)
#Pour chaque récepteur on demande a l'application les données traitées du fichier ( niveau sonore et cumuls )
for idrecp in recplist:
#recp devient l'objet ayant comme indice idrecp (entier)
recp=ui.element(idrecp)
recpinfos=recp.getinfos()
if recpinfos["name"]=="soundpressure":
recpdata={}
#on recupere l'element parent (le dossier de récepteur ponctuel)
pere=ui.element(recp.getinfos()["parentid"])
#on demande le calcul des paramètres sonores
if pere.getelementbylibelle('acoustic_param')==-1:
ui.application.sendevent(recp,ui.idevent.IDEVENT_RECP_COMPUTE_ACOUSTIC_PARAMETERS,{"TR":"30"})
#application.sendevent(pere,idevent.IDEVENT_RELOAD_FOLDER)
nomrecp=pere.getinfos()["label"]
#on recupere les données calculées
params=ui.element(pere.getelementbylibelle('acoustic_param'))
#on stocke dans gridspl le tableau des niveaux de pression
gridparam=ui.application.getdataarray(params)
rotated=zip(*gridparam)
labels=gridparam[0]
tr30index=labels.index(ui._("TR-%g (s)") % (30))
edt_index=labels.index(ui._("EDT (s)"))
#on ajoute les données
recpdata["sound_level"]=ui.application.getdataarray(recp)
recpdata["rt30"]=map(ReplaceNanByZero,rotated[tr30index])
recpdata["edt"]=map(ReplaceNanByZero,rotated[edt_index])
data[nomrecp]=recpdata
return data
def OnUpdate(self,elid):
if self.elid==elid:
lastchilds=set([child[0] for child in ui.element(self.elid).childs()])
if len(lastchilds)>len(self.oldchild):
newchilds=lastchilds-self.oldchild
for newchild in newchilds:
self.func(newchild)
self.oldchild=lastchilds
def LinkSourcePositionWithReceiverPosition(sourceId,ReceiverId):
#Il faut ajouter les coordonnées X,Y,Z de décalage avec la source
#Ainsi que le nom de la source dans cette propriété
receiver=ui.element(ReceiverId)
source=ui.element(sourceId)
posel=ui.element(receiver.getelementbylibelle("pos_recepteur"))
if(posel.hasproperty("linkedsource")):
#Mettre a jour la propriete
posel.updatestringconfig("linkedsource",source.getinfos()["name"])
else:
#Add property
_("Linked source")
ui.element(posel.appendpropertytext("linkedsource","linkedsource",source.getinfos()["name"])).hide()
if not SourcePosToReceiverPosTrackerLst.has_key(ReceiverId):
SourcePosToReceiverPosTrackerLst[ReceiverId]=PositionUpdater(ReceiverId,True)
else:
SourcePosToReceiverPosTrackerLst[ReceiverId].UpdateLinker()
def getmenu(self, typeel, idel, menu):
el = ui.element(idel)
infos = el.getinfos()
if infos["name"] == "Récepteurs_Ponctuels":
menu.insert(0, (_("Normalise SPL"), self.MakeSPLNormalGridEventId))
return True
else:
return False
def getmenu(self,typeel,idel,menu):
el=ui.element(idel)
infos=el.getinfos()
if infos["name"]=="Récepteurs_Ponctuels":
menu.insert(0,(_("Normalise SPL"),self.MakeSPLNormalGridEventId))
return True
else:
return False
def UpdateLinker(self):
receiver = ui.element(self.receiverid)
dir = None
if not self.isPositionTracker:
dir = ui.element(receiver.getelementbylibelle("direction_dot"))
else:
dir = ui.element(receiver.getelementbylibelle("pos_recepteur"))
if dir.hasproperty("linkedsource"):
labelsource = dir.getstringconfig("linkedsource")
self.srclbl = labelsource
rootscene = ui.element(ui.application.getrootscene())
sourcroot = ui.element(
rootscene.getelementbytype(
ui.element_type.ELEMENT_TYPE_SCENE_SOURCES))
sourceid = sourcroot.getelementbylibelle(labelsource)
if (sourceid != -1):
self.srcid = sourceid
src = ui.element(sourceid)
posid = src.getelementbylibelle("pos_source")
pos = ui.element(posid)
self.sourceposid = posid
pos.register_update_manager(
self.OnSourcePositionChange
) #Lie la méthode à la mise à jour de la position de la source
src.register_update_manager(
self.OnSourceLabelChange
) #Lie la méthode à la mise à jour de la source pour le changement de libellé
if not self.isPositionTracker:
receiver.updatepositionconfig(
"direction_dot", src.getpositionconfig("pos_source"))
def __init__(self,receiverId,isPositionTracker=False):
self.isPositionTracker=isPositionTracker
self.receiverid=receiverId
self.sourceposid=-1
self.srcid=-1
self.srclbl=""
self.UpdateLinker()
if self.isPositionTracker:
self.old_src_pos=ui.element(self.srcid).getpositionconfig("pos_source")
def getmenu(self, typeel, idel, menu):
el = ui.element(idel)
infos = el.getinfos()
if infos["name"] == u"Punctual receivers":
menu.insert(0, ())
menu.insert(0, ("Compute Energy Density", self.GetD))
return True
else:
return False
def getmenu(self, typeel, idel, menu):
el = ui.element(idel)
infos = el.getinfos()
if infos["name"] == u"Punctual receivers":
menu.insert(0, ())
menu.insert(0, (u"Merge point receivers", self.GetMixedLevelid))
return True
else:
return False
def align_on_same_point(self,idel):
lbl_toptx=_(u"Orient to position x (m)")
lbl_topty=_(u"Orient to position y (m)")
lbl_toptz=_(u"Orient to position z (m)")
res=ui.application.getuserinput(_(u"Orient a group of receivers to a point"),
_(u"Please enter the coordinates of the orientation point"),
{ lbl_toptx : "0",
lbl_topty : "0",
lbl_toptz : "0",
})
if res[0]:
grprecp=ui.element(idel)
recplst=grprecp.getallelementbytype(ui.element_type.ELEMENT_TYPE_SCENE_RECEPTEURSP_RECEPTEUR)
topt=[float(res[1][lbl_toptx]), float(res[1][lbl_topty]), float(res[1][lbl_toptz])]
for recpid in recplst:
recp=ui.element(recpid)
recp.updatepositionconfig("direction_dot",topt)
def getmenu(self,typeel,idel,menu):
#si le groupe n'est pas vide
if len(ui.element(idel).childs())>0:
menu.insert(2,(_(u"Orienter le groupe vers.."),self.alignfuncid))
menu.insert(2,(_(u"Translation des récepteurs ponctuels"),self.translaterpfuncid))
menu.insert(2,(_(u"Rotation des récepteurs ponctuels"),self.rotaterpfuncid))
menu.insert(2,())
menu.insert(2,(_(u"Créer une grille de récepteurs ponctuels"),self.makelinerecpid,"Bitmaps/popup_new.png"))
return True
def __init__(self,receiverId,isPositionTracker=False):
self.isPositionTracker=isPositionTracker
self.receiverid=receiverId
self.sourceposid=-1
self.srcid=-1
self.srclbl=""
self.UpdateLinker()
if self.isPositionTracker:
self.old_src_pos=ui.element(self.srcid).getpositionconfig("pos_source")
def getmenu(self,typeel,idel,menu):
#si le groupe n'est pas vide
if len(ui.element(idel).childs())>0:
menu.insert(2,(_(u"Orient the group to a position"),self.alignfuncid))
menu.insert(2,(_(u"Translation of receivers"),self.translaterpfuncid))
menu.insert(2,(_(u"Rotation of receivers"),self.rotaterpfuncid))
menu.insert(2,())
menu.insert(2,(_(u"Create a receiver grid"),self.makelinerecpid,"Bitmaps/popup_new.png"))
return True
