Example #1
0
 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]])
Example #2
0
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]
        ]
Example #3
0
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
    )
Example #4
0
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]
        ]
Example #5
0
 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]])
Example #6
0
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
Example #7
0
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
Example #8
0
    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]])
Example #9
0
    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])
Example #10
0
 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]])
Example #11
0
def GetCurrentProjectPath():
    projconfel = ui.element(
        ui.element(ui.application.getrootscene()).getelementbytype(
            ui.element_type.ELEMENT_TYPE_SCENE_PROJET_CONFIGURATION
        )
    )
    return projconfel.getstringconfig("urlsave")
Example #12
0
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)
Example #13
0
    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
Example #14
0
 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)
Example #15
0
    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
Example #16
0
 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\\")
Example #17
0
 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
Example #18
0
 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))
Example #19
0
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
Example #20
0
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
Example #21
0
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
Example #22
0
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
Example #23
0
 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
Example #24
0
 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)
Example #25
0
 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
Example #26
0
 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)
Example #27
0
 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]])
Example #28
0
 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
Example #29
0
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()
Example #30
0
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()
Example #31
0
 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
Example #32
0
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()    
Example #33
0
    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)
Example #34
0
 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()
Example #35
0
    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
Example #36
0
 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
Example #37
0
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
Example #38
0
 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
Example #39
0
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()
Example #40
0
 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
Example #41
0
 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
Example #42
0
 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"))
Example #43
0
 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")
Example #44
0
 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
Example #45
0
 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
Example #46
0
 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)
Example #47
0
 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
Example #48
0
 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")
Example #49
0
 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