Beispiel #1
0
def sortedEvents(trial):
    """
        Sort out events of a trial

        :Parameters:
            - `trial` (openma.trial) - an openma trial instance

    """

    evs = trial.findChildren(ma.T_Event)

    contextLst = []  # recuperation de tous les contextes
    for it in evs:
        if it.context() not in contextLst:
            contextLst.append(it.context())

    valueTime = []  # recuperation de toutes les frames SANS doublons
    for it in evs:
        if it.time() not in valueTime:
            valueTime.append(it.time())
    valueTime.sort()  # trie

    events = ma.Node("SortedEvents")  #events =list()
    for contextLst_it in contextLst:
        for timeSort in valueTime:
            for it in evs:
                if it.time() == timeSort and it.context() == contextLst_it:
                    ev = ma.Event(it.name(), it.time(), contextLst_it, "")
                    ev.addParent(events)

    events.addParent(trial.child(0))
Beispiel #2
0
    def appendEvents(self):

        eventType = "Foot Strike"
        eventContext = "Left"
        if NEXUS.GetEvents(self.m_subject, eventContext, eventType)[0] != []:
            for frame in NEXUS.GetEvents(self.m_subject, eventContext,
                                         eventType)[0]:
                if frame >= self.m_firstFrame and frame <= self.m_lastFrame:
                    time = (frame - 1) / self.m_framerate
                    ev = ma.Event(eventType, time, eventContext,
                                  utils.str(self.m_subject),
                                  self.m_trial.events())

        eventType = "Foot Off"
        eventContext = "Left"
        if NEXUS.GetEvents(self.m_subject, eventContext, eventType)[0] != []:
            for frame in NEXUS.GetEvents(self.m_subject, eventContext,
                                         eventType)[0]:
                if frame >= self.m_firstFrame and frame <= self.m_lastFrame:
                    time = (frame - 1) / self.m_framerate
                    ev = ma.Event(eventType, time, eventContext,
                                  utils.str(self.m_subject),
                                  self.m_trial.events())

        eventType = "Foot Strike"
        eventContext = "Right"
        if NEXUS.GetEvents(self.m_subject, eventContext, eventType)[0] != []:
            for frame in NEXUS.GetEvents(self.m_subject, eventContext,
                                         eventType)[0]:
                if frame >= self.m_firstFrame and frame <= self.m_lastFrame:
                    time = (frame - 1) / self.m_framerate
                    ev = ma.Event(eventType, time, eventContext,
                                  utils.str(self.m_subject),
                                  self.m_trial.events())

        eventType = "Foot Off"
        eventContext = "Right"
        if NEXUS.GetEvents(self.m_subject, eventContext, eventType)[0] != []:
            for frame in NEXUS.GetEvents(self.m_subject, eventContext,
                                         eventType)[0]:
                if frame >= self.m_firstFrame and frame <= self.m_lastFrame:
                    time = (frame - 1) / self.m_framerate
                    ev = ma.Event(eventType, time, eventContext,
                                  utils.str(self.m_subject),
                                  self.m_trial.events())

        eventType = "Event"
        eventContext = "General"
        if NEXUS.GetEvents(self.m_subject, eventContext, eventType)[0] != []:
            for frame in NEXUS.GetEvents(self.m_subject, eventContext,
                                         eventType)[0]:
                if frame >= self.m_firstFrame and frame <= self.m_lastFrame:
                    time = (frame - 1) / self.m_framerate
                    ev = ma.Event(eventType, time, eventContext,
                                  utils.str(self.m_subject),
                                  self.m_trial.events())

        eventType = "Left-FP"
        eventContext = "General"
        if NEXUS.GetEvents(self.m_subject, eventContext, eventType)[0] != []:
            for frame in NEXUS.GetEvents(self.m_subject, eventContext,
                                         eventType)[0]:
                if frame >= self.m_firstFrame and frame <= self.m_lastFrame:
                    time = (frame - 1) / self.m_framerate
                    ev = ma.Event(eventType, time, eventContext,
                                  utils.str(self.m_subject),
                                  self.m_trial.events())

        eventType = "Right-FP"
        eventContext = "General"
        if NEXUS.GetEvents(self.m_subject, eventContext, eventType)[0] != []:
            for frame in NEXUS.GetEvents(self.m_subject, eventContext,
                                         eventType)[0]:
                if frame >= self.m_firstFrame and frame <= self.m_lastFrame:
                    time = (frame - 1) / self.m_framerate
                    ev = ma.Event(eventType, time, eventContext,
                                  utils.str(self.m_subject),
                                  self.m_trial.events())

        eventType = "Start"
        eventContext = "Left"
        if NEXUS.GetEvents(self.m_subject, eventContext, eventType)[0] != []:
            for frame in NEXUS.GetEvents(self.m_subject, eventContext,
                                         eventType)[0]:
                if frame >= self.m_firstFrame and frame <= self.m_lastFrame:
                    time = (frame - 1) / self.m_framerate
                    ev = ma.Event(eventType, time, eventContext,
                                  utils.str(self.m_subject),
                                  self.m_trial.events())

        eventType = "End"
        eventContext = "Left"
        if NEXUS.GetEvents(self.m_subject, eventContext, eventType)[0] != []:
            for frame in NEXUS.GetEvents(self.m_subject, eventContext,
                                         eventType)[0]:
                if frame >= self.m_firstFrame and frame <= self.m_lastFrame:
                    time = (frame - 1) / self.m_framerate
                    ev = ma.Event(eventType, time, eventContext,
                                  utils.str(self.m_subject),
                                  self.m_trial.events())
Beispiel #3
0
def convertBtkAcquisition(acq, returnType="Trial"):

    root = ma.Node('root')
    trial = ma.Trial("Trial", root)

    framerate = acq.GetPointFrequency()
    firstFrame = acq.GetFirstFrame()

    numberAnalogSamplePerFrame = acq.GetNumberAnalogSamplePerFrame()
    analogFramerate = acq.GetAnalogFrequency()

    if firstFrame == 1:
        time_init = 0.0
    else:
        time_init = firstFrame / framerate

    for it in btk.Iterate(acq.GetPoints()):

        label = it.GetLabel()
        values = it.GetValues()
        residuals = it.GetResiduals()
        desc = it.GetDescription()

        data = np.zeros((values.shape[0], 4))
        data[:, 0:3] = values
        data[:, 3] = residuals[:, 0]

        if it.GetType() == btk.btkPoint.Marker:
            ts = ma.TimeSequence(str(label), 4, data.shape[0], framerate,
                                 time_init, ma.TimeSequence.Type_Marker, "mm",
                                 trial.timeSequences())

        elif it.GetType() == btk.btkPoint.Angle:
            ts = ma.TimeSequence(str(label), 4, data.shape[0], framerate,
                                 time_init, ma.TimeSequence.Type_Angle, "Deg",
                                 trial.timeSequences())

        elif it.GetType() == btk.btkPoint.Force:
            ts = ma.TimeSequence(str(label), 4, data.shape[0], framerate,
                                 time_init, ma.TimeSequence.Type_Force,
                                 "N.Kg-1", trial.timeSequences())

        elif it.GetType() == btk.btkPoint.Moment:
            ts = ma.TimeSequence(str(label), 4, data.shape[0], framerate,
                                 time_init, ma.TimeSequence.Type_Moment,
                                 "Nmm.Kg-1", trial.timeSequences())

        elif it.GetType() == btk.btkPoint.Power:
            ts = ma.TimeSequence(str(label), 4, data.shape[0], framerate,
                                 time_init, ma.TimeSequence.Type_Power,
                                 "Watt.Kg-1", trial.timeSequences())

        else:
            logging.warning(
                "[pyCGM2] point [%s] not copied into openma trial" % (label))

        ts.setData(data)
        ts.setDescription(desc)

    for it in btk.Iterate(acq.GetAnalogs()):

        label = it.GetLabel()
        values = it.GetValues()
        desc = it.GetDescription()

        data = values

        ts = ma.TimeSequence(str(label), 1, data.shape[0], analogFramerate,
                             time_init, ma.TimeSequence.Type_Analog, "V", 1.0,
                             0.0, [-10.0, 10.0], trial.timeSequences())
        ts.setData(data)
        ts.setDescription(desc)

    for it in btk.Iterate(acq.GetEvents()):

        label = it.GetLabel()
        time = it.GetTime()
        context = it.GetContext()
        subject = it.GetSubject()

        ev = ma.Event(label, time, context, str(subject), trial.events())

    sortedEvents(trial)

    if returnType == "Trial":
        return trial
    else:
        return root