def mot_get_label(tracklets, new_tracklet, param):
    #look for the tracklet before new tracklet
    affinity = []
    for trk in tracklets:
        temp_Trk = Tracklet()
        temp_Trk.FMotion = trk.FMotion
        XX, PP = mot_motion_model_generation(trk, param, 'Backward')
        temp_Trk.BMotion.X = XX
        temp_Trk.BMotion.P = PP
        temp_Trk.init_time = trk.ifr
        temp_Trk.end_time = trk.last_update

        new_Trk = Tracklet()
        new_Trk.FMotion = new_tracklet.FMotion
        XX, PP = mot_motion_model_generation(new_tracklet, param, 'Backward')
        new_Trk.BMotion.X = XX
        new_Trk.BMotion.P = PP
        new_Trk.init_time = new_tracklet.ifr
        new_Trk.end_time = new_tracklet.last_update

        if trk.last_update < new_tracklet.ifr:
            motion_similarity = mot_motion_similarity(temp_Trk, new_Trk, param,
                                                      "Trk")
            a_model_affinity = cal_a_model_affinity(
                [trk.A_model_tail], [new_tracklet.A_model_head], 0)[0]
            final_affinity = motion_similarity * a_model_affinity
            affinity.append([final_affinity, trk.label])
        if trk.ifr < new_tracklet.last_update:
            motion_similarity = mot_motion_similarity(new_Trk, temp_Trk, param,
                                                      "Trk")
            a_model_affinity = cal_a_model_affinity(
                [trk.A_model_head], [new_tracklet.A_model_tail], 0)[0]
            final_affinity = motion_similarity * a_model_affinity
            affinity.append([final_affinity, trk.label])
    if len(affinity) > 0:
        print(affinity, 1213123123123123)
        affinity = sorted(affinity, key=(lambda x: x[0]), reverse=True)
        max_affinity = affinity[0]
        if max_affinity[0] > param.similar_thresh:
            new_tracklet.label = max_affinity[1]
        else:
            new_tracklet.label = Labelling(param)
    else:
        new_tracklet.label = Labelling(param)
Beispiel #2
0
def MOT_Global_Association(Trk = None,Obs_grap = None,Obs_info = None,param = None,fr = None,*args,**kwargs):

    ILDA  =  param.ILDA
    Refer = []
    Test = []
    all_indx = [i for i in range(0,len(Trk))]
    low_indx,_,_ = Idx2Types(Trk,'Low')
    high_indx = np.setdiff1d(all_indx,low_indx)
    yidx = np.where(Obs_grap[fr].iso_idx  ==  1)[0]
    yhist = Obs_info.yhist
    ystate = Obs_info.ystate
    ystates_ids = Obs_info.ystates_ids
    High_trk = []
    Low_trk = []
    Y_set = []
    if len(low_indx) !=0:
        # For tracklets with low confidence
        for ii in range(0,len(low_indx)):
            i = low_indx[ii]
            temp_Trk_low = Tracklet()
            temp_Trk_low.hist  =  Trk[i].A_Model
            temp_Trk_low.FMotion  =  Trk[i].FMotion
            temp_Trk_low.last_update  =  Trk[i].last_update
            temp_Trk_low.h  =  Trk[i].state[-1][3]
            temp_Trk_low.w  =  Trk[i].state[-1][2]
            temp_Trk_low.type  =  Trk[i].type
            temp_Trk_low.end_time = Trk[i].efr
            Low_trk.append(temp_Trk_low)
        # For tracklet with high confidence
        for jj in range(0,len(high_indx)):
            j = high_indx[jj]
            temp_Trk_high = Tracklet()
            temp_Trk_high.hist  =  Trk[j].A_Model
            temp_Trk_high.h  =  Trk[j].state[-1][3]
            temp_Trk_high.w  =  Trk[j].state[-1][2]
            temp_Trk_high.FMotion  =  Trk[j].FMotion
            XX,PP = mot_motion_model_generation(Trk[j],param,'Backward',nargout = 2)
            temp_Trk_high.BMotion.X  =  XX
            temp_Trk_high.BMotion.P  =  PP
            temp_Trk_high.last_update  =  Trk[j].last_update
            temp_Trk_high.init_time  =  Trk[j].ifr
            High_trk.append(temp_Trk_high)
        iso_label = []
        if len(yidx) != 0:
            # For detections
            for jj in range(0,len(yidx)):
                j = yidx[jj]
                temp_y_set = Z_item()
                temp_y_set.hist  =  yhist[:,:,j]
                temp_y_set.pos  =  [ystate[j][0],ystate[j][1]]
                temp_y_set.h  =  ystate[j][3]
                temp_y_set.w  =  ystate[j][2]
                Y_set.append(temp_y_set)
                iso_label = j
        thr = param.obs_thr
        score_trk = mot_eval_association_matrix(Low_trk,High_trk,param,'Trk',ILDA)
        score_obs = mot_eval_association_matrix(Low_trk,Y_set,param,'Obs',ILDA)
        score_mat = np.concatenate((score_trk,score_obs),axis=1)
        matching,Affinity = mot_association_hungarian(score_mat,thr,nargout = 2)
        alpha = param.alpha
        rm_idx = []
        for m in range(0,len(Affinity)):
            mat_idx = matching[1,m]
            if mat_idx <=  len(high_indx) - 1:
                t_idx = low_indx[matching[0,m]]
                y_idx = high_indx[matching[1,m]]
                Trk[y_idx].ifr  =  Trk[t_idx].ifr
                fr1 = Trk[t_idx].ifr
                fr2 = Trk[t_idx].efr
                for kk in range(fr1,fr2):
                    Trk[y_idx].state[kk] = Trk[t_idx].state[kk]
                numHyp = len(Trk[t_idx].hyp.score)
                for kk in range(fr1,numHyp):
                    Trk[y_idx].hyp.score[kk] = Trk[t_idx].hyp.score[kk]
                    Trk[y_idx].hyp.ystate[kk] = Trk[t_idx].hyp.ystate[kk]
                    Trk[y_idx].hyp.ystates_ids[kk] = Trk[t_idx].hyp.ystates_ids[kk]
                for kk in range(numHyp + 1,fr):
                    Trk[y_idx].hyp.score[kk] = param.init_prob
                    Trk[y_idx].hyp.ystate[kk] = []
                    Trk[y_idx].hyp.ystates_ids[kk] = -1
                Trk[y_idx].A_Model  =  alpha*Trk[t_idx].A_Model + (1 - alpha)*Trk[y_idx].A_Model
                XX = []
                numState = len(Trk[y_idx].state)
                XX[1,:] = Trk(y_idx).state[fr1](1)
                XX[3,:] = Trk(y_idx).state[fr1](2)
                XX[2,:] = 0
                XX[4,:] = 0
                PP = param.P
                for ff in range(fr1,numState):
                    tState = Trk(y_idx).state[ff]
                    if logical_not(isempty(tState)):
                        XX,PP = km_estimation(XX,tState(range(1,2)),param,PP,nargout = 2)
                    else:
                        tState = Trk(y_idx).state[fr2]
                        XX,PP = km_estimation(XX,[],param,PP,nargout = 2)
                        Trk(y_idx).state[ff][range(1,2),:] = concat([[XX(1)],[XX(3)]])
                        Trk(y_idx).state[ff][range(3,4),:] = concat([[tState(1)],[tState(3)]])
                    Trk(y_idx).FMotion.X[:,ff] = XX
                    Trk(y_idx).FMotion.P[:,:,ff] = PP
                Trk(y_idx).label  =  copy(Trk[t_idx].label)
                Trk(y_idx).type  =  copy('High')
                rm_idx = concat([rm_idx,t_idx])
            else:
                m_idx = matching[1,m] - len(high_indx)
                t_idx = low_indx[matching[0,m]]
                y_idx = yidx[m_idx]
                for i in range(len(Trk[t_idx].hyp.score),fr):
                    Trk[t_idx].hyp.score.append(0)
                    Trk[t_idx].hyp.ystate.append([])
                    Trk[t_idx].hyp.ystates_ids.append(-1)
                Trk[t_idx].hyp.score.append(Affinity[m])
                Trk[t_idx].hyp.ystate.append(ystate[y_idx])
                Trk[t_idx].hyp.ystates_ids.append(ystates_ids[y_idx])
                Trk[t_idx].hyp.new_tmpl  =  yhist[:,:,y_idx]
                Trk[t_idx].last_update  =  fr
                Obs_grap[fr].iso_idx[y_idx] = 0
        if len(rm_idx) != 0:
            Trk[rm_idx] = []
    
    return Trk,Obs_grap
def MOT_Local_Association(Trk=None,
                          detections=None,
                          Obs_grap=None,
                          param=None,
                          fr=None,
                          rgbimg=None,
                          nargout1=None,
                          *args,
                          **kwargs):
    ILDA = param.ILDA

    Z_meas = detections[fr]  #represent the detections in current frame
    Z_meas = [detection[2:6] for detection in Z_meas
              ]  #choose the location(x,y,w,h) from raw data
    ystates_ids = [detection[1] for detection in detections[fr]]
    ystate = Z_meas
    obs_grap = Obs_Graph()
    Obs_grap.append(obs_grap)
    Obs_grap[fr].iso_idx = np.ones((len(detections[fr])))
    obs_info = Obs_info()
    obs_info.ystate = []
    obs_info.yhist = []
    obs_info.ystates_ids = []
    if ~(np.all(ystate == 0)):
        yhist = mot_appearance_model_generation(
            rgbimg, param, ystate,
            True)  #get the apperance model of the detections in current frame
        obs_info.ystate = ystate
        obs_info.yhist = yhist
        obs_info.ystates_ids = ystates_ids
        tidx, _, _ = Idx2Types(
            Trk, 'High')  #return the index of high confidence Tracklet
        yidx = np.where(Obs_grap[fr].iso_idx == 1)[
            0]  #return the index of detections in current frame
        if len(tidx) != 0 and len(yidx) != 0:
            Trk_high = []
            Z_set = []
            trk_label = []
            conf_set = []
            #to generate a list of high confidence tracklet
            for ii in range(0, len(tidx)):
                i = tidx[ii]
                temp_Trk_high = Tracklet()
                temp_Trk_high.hist = Trk[i].A_Model
                temp_Trk_high.FMotion = Trk[i].FMotion
                temp_Trk_high.last_update = Trk[i].last_update
                temp_Trk_high.h = Trk[i].state[-1][3]
                temp_Trk_high.w = Trk[i].state[-1][2]
                temp_Trk_high.type = Trk[i].type
                Trk_high.append(temp_Trk_high)
                trk_label.append(Trk[i].label)
                conf_set.append(Trk[i].Conf_prob)
            # For detections in current frame
            meas_label = []
            for jj in range(0, len(yidx)):
                j = yidx[
                    jj]  #get the index of the j detection of detections in current frames
                z_item = Z_item(
                )  #generate a object in order to record every detection's information include x,y,w,h, and Apperance model
                z_item.hist = yhist[:, :, j]
                z_item.pos = [ystate[j][0], ystate[j][1]]
                z_item.h = ystate[j][3]
                z_item.w = ystate[j][2]
                Z_set.append(z_item)
                meas_label.append(j)
            thr = param.obs_thr
            #generate the score matrix between Tracklet with high confidence and Detections in current frame

            score_mat = mot_eval_association_matrix(Trk_high, Z_set, param,
                                                    'Obs', ILDA)
            confidence = []
            for i in Trk:
                confidence.append(i.Conf_prob)
            print(score_mat)
            #matching by hungarian Algorithm the the socre matrix shape should be[len(high_trk),len(high_trk]
            matching, __ = mot_association_hungarian(score_mat, thr, nargout=2)
            print(matching)
            if matching.size != 0:
                for i in range(0, matching.shape[1]):
                    ass_idx_row = matching[0, i]
                    ta_idx = tidx[ass_idx_row]
                    ass_idx_col = matching[1, i]
                    ya_idx = yidx[ass_idx_col]
                    ListInsert(Trk[ta_idx].hyp.score, fr,
                               score_mat[matching[0, i], matching[1, i]], 0)
                    ListInsert(Trk[ta_idx].hyp.ystate, fr, ystate[ya_idx], [])
                    ListInsert(Trk[ta_idx].hyp.ystates_ids, fr,
                               ystates_ids[ya_idx], -1)

                    #Trk[ta_idx].hyp.score.append(score_mat[matching[0,i],matching[1,i]])
                    #Trk[ta_idx].hyp.ystate.append(ystate[ya_idx])
                    Trk[ta_idx].hyp.new_tmpl = yhist[:, :, ya_idx]
                    Trk[ta_idx].last_update = fr
                    Obs_grap[fr].iso_idx[ya_idx] = 0

    return Trk, Obs_grap, obs_info
def MOT_Init_Tracklets_Generation(init_Trks, window_tracklets, cfr, param):
    for tracklet in window_tracklets:
        #if one tracklet in the window has never been matched for 5 frames above,cut this part of this window tracklet and make it a new init tracklet
        if cfr - tracklet.ifr + 1 == 5:
            ifr = tracklet.ifr
            new_init_tracklet = Tracklet()
            new_init_tracklet.Conf_prob = tracklet.Conf_prob
            new_init_tracklet.type = tracklet.type
            new_init_tracklet.reliable = tracklet.reliable
            new_init_tracklet.isnew = 1
            new_init_tracklet.sub_img = []
            new_init_tracklet.status = tracklet.status
            new_init_tracklet.label = tracklet.label
            new_init_tracklet.ifr = ifr
            new_init_tracklet.efr = -1
            new_init_tracklet.last_update = cfr
            new_init_tracklet.state = [[]] * (cfr + 1)
            new_init_tracklet.A_model_list = tracklet.A_model_list[:cfr]
            new_init_tracklet.FMotion.X = tracklet.FMotion.X[:, cfr].copy()
            new_init_tracklet.FMotion.P = tracklet.FMotion.P[:, :, cfr].copy()
            new_init_tracklet.hyp.score = tracklet.hyp.score[:cfr].copy()
            new_init_tracklet.hyp.ystate = tracklet.hyp.score[:cfr].copy()
            new_init_tracklet.state = tracklet.state[:cfr].copy()

            #remove the information of the part which has already become a new init_tracklet
            fr = cfr
            while 1:
                if len(tracklet.hyp.ystate[fr]) > 0:
                    tracklet.ifr = fr
                    break
                fr += 1
            for i in range(cfr + 1 - 5, cfr + 1):
                tracklet.state[i] = []
                tracklet.A_model_list[i] = None
                tracklet.FMotion.X[:, i] = 0
                tracklet.FMotion.P[:, :, i] = 0
                tracklet.hyp.score[i] = 0
                tracklet.hyp.ystate[i] = []
                tracklet.state[i] = []
            mot_appearance_model_update(new_init_tracklet)
            init_Trks.append(new_init_tracklet)

            #if the window_tracklet of which apart is concated with another init tracklet,and the rest tracklet is already empty,then delete it from the window tracklet list
            if checkNone(tracklet) == True:
                window_tracklets.remove(tracklet)
                print("delete 1 window tracklet...")
            print("Init Tracklet Generated:len(Trk)+1")
def MOT_Global_Association(Trk = None,Tracklets_window = None,param = None,fr = None,Obs_grap_window = None,detections = None,*args,**kwargs):

    obs_grap = Obs_Graph()
    Obs_grap_window.append(obs_grap)
    Obs_grap_window[fr].iso_idx = np.ones((len(detections[fr])))
    ILDA  =  param.ILDA
    Refer = []
    Test = []
    all_indx = [i for i in range(0,len(Trk))]
    all_indx_window = [i for i in range(0,len(Tracklets_window))]
    low_indx,_,_ = Idx2Types(Tracklets_window,'Low')
    high_indx = np.setdiff1d(all_indx_window,low_indx)
    init_indx = all_indx
    init_trk = []
    High_trk = []
    Low_trk = []
    window_trk = []
    Y_set = []
    if len(high_indx) !=0:
        # For tracklets with low confidence in the window
        for ii in range(0,len(low_indx)):
            i = low_indx[ii]
            temp_Trk_low = Tracklet()
            temp_Trk_low.hist  =  Tracklets_window[i].A_Model
            temp_Trk_low.FMotion  =  Tracklets_window[i].FMotion
            temp_Trk_low.last_update  =  Tracklets_window[i].last_update
            temp_Trk_low.h  =  Tracklets_window[i].state[-1][3]
            temp_Trk_low.w  =  Tracklets_window[i].state[-1][2]
            temp_Trk_low.type  =  Tracklets_window[i].type
            temp_Trk_low.end_time = Tracklets_window[i].efr
            Low_trk.append(temp_Trk_low)
        # For tracklet with high confidence in the window
        for jj in range(0,len(all_indx_window)):
            j = all_indx_window[jj]
            temp_Trk_high = Tracklet()
            temp_Trk_high.hist  =  Tracklets_window[j].A_model_tail
            print(jj,j,len(Tracklets_window[j].state),Tracklets_window[j].state)
            temp_Trk_high.h  =  Tracklets_window[j].state[-1][3]
            temp_Trk_high.w  =  Tracklets_window[j].state[-1][2]
            temp_Trk_high.FMotion  =  Tracklets_window[j].FMotion
            XX,PP = mot_motion_model_generation(Tracklets_window[j],param,'Backward',nargout = 2)
            temp_Trk_high.BMotion.X  =  XX
            temp_Trk_high.BMotion.P  =  PP
            temp_Trk_high.last_update  =  Tracklets_window[j].last_update
            temp_Trk_high.init_time  =  Tracklets_window[j].ifr
            temp_Trk_high.end_time = Tracklets_window[j].efr
            window_trk.append(temp_Trk_high)
        iso_label = []
        
    for jj in range(0,len(all_indx)):
        j = all_indx[jj]
        temp_init_trk = Tracklet()
        temp_init_trk.hist  =  Trk[j].A_model_tail
        temp_init_trk.h  =  Trk[j].state[-1][3]
        temp_init_trk.w  =  Trk[j].state[-1][2]
        temp_init_trk.FMotion  =  Trk[j].FMotion
        XX,PP = mot_motion_model_generation(Trk[j],param,'Backward',nargout = 2)
        temp_init_trk.BMotion.X  =  XX
        temp_init_trk.BMotion.P  =  PP
        temp_init_trk.last_update  =  Trk[j].last_update
        temp_init_trk.init_time  =  Trk[j].ifr
        temp_init_trk.end_time  =  Trk[j].last_update
        init_trk.append(temp_init_trk)
        
    thr = param.obs_thr
    score_trk = mot_eval_association_matrix(init_trk,window_trk,param,'Trk',ILDA)
    print("score_trk matrix:",score_trk)
    matching,Affinity = mot_association_hungarian(score_trk,thr)
    alpha = param.alpha
    rm_idx = []
    print("matching matrix:",matching)
    #association the tracklet in the window to init tracklets
    for m in range(0,len(Affinity)):
        w_idx = all_indx_window[matching[0,m]]
        init_idx = all_indx[matching[1,m]]
        fr1 = Tracklets_window[w_idx].ifr
        fr2 = Tracklets_window[w_idx].last_update
        for kk in range(fr1,fr2):
            
            ListInsert(Trk[init_idx].state,kk,Tracklets_window[w_idx].state[kk],[])
        numHyp = len(Tracklets_window[w_idx].hyp.score)
        #copy hyp information from window_tracklets to init_tracklets
        for kk in range(fr1,numHyp):
            mot_tracklets_concat(Trk[init_idx],Tracklets_window[w_idx],kk,param)
        XX = np.array([0,0,0,0])
        numState = len(Trk[init_idx].state)
        XX[0] = Trk[init_idx].state[fr1][0]
        XX[2] = Trk[init_idx].state[fr1][1]
        PP = param.P
        Trk[init_idx].type  =  'High'
        mot_appearance_model_update(Trk[init_idx])
        rm_idx.append(w_idx)
    if len(rm_idx) != 0:
        print("removed tracklets ids of which are {}".format(rm_idx))
        for idx in sorted(rm_idx,reverse=True):
            #mot_count_ids(tracklets_window[idx],param)
            Tracklets_window.pop(idx)
    
    return Trk
def MOT_Window_Association(Tracklets_window=None,
                           param=None,
                           fr=None,
                           detections=None,
                           Obs_grap_window=None,
                           *args,
                           **kwargs):
    #get the head and tail list of tracklet in order to decline the calculation
    head_index, tail_index = getHeadAndTailTrk(Tracklets_window)
    ILDA = param.ILDA
    all_indx_window = [i for i in range(0, len(Tracklets_window))]
    window_trk_head = []
    window_trk_tail = []
    High_trk = []
    Low_trk = []
    Y_set = []
    # For trackletin the window with head A_Model
    for jj in range(0, len(head_index)):
        j = head_index[jj]
        temp_Trk = Tracklet()
        temp_Trk.hist = Tracklets_window[j].A_model_tail
        temp_Trk.h = Tracklets_window[j].state[-1][3]
        temp_Trk.w = Tracklets_window[j].state[-1][2]
        temp_Trk.FMotion = Tracklets_window[j].FMotion
        XX, PP = mot_motion_model_generation(Tracklets_window[j], param,
                                             'Forward')
        temp_Trk.BMotion.X = XX
        temp_Trk.BMotion.P = PP
        temp_Trk.last_update = Tracklets_window[j].last_update
        temp_Trk.init_time = Tracklets_window[j].ifr
        temp_Trk.end_time = Tracklets_window[j].last_update
        window_trk_head.append(temp_Trk)
    iso_label = []

    # For trackletin the window with tail A_Model
    for jj in range(0, len(tail_index)):
        j = tail_index[jj]
        temp_Tracklets_window = Tracklet()
        temp_Tracklets_window.hist = Tracklets_window[j].A_model_head
        temp_Tracklets_window.h = Tracklets_window[j].state[
            Tracklets_window[j].ifr][3]
        temp_Tracklets_window.w = Tracklets_window[j].state[
            Tracklets_window[j].ifr][2]
        temp_Tracklets_window.FMotion = Tracklets_window[j].FMotion
        XX, PP = mot_motion_model_generation(Tracklets_window[j], param,
                                             'Backward')
        temp_Tracklets_window.BMotion.X = XX
        temp_Tracklets_window.BMotion.P = PP
        temp_Tracklets_window.last_update = Tracklets_window[j].last_update
        temp_Tracklets_window.init_time = Tracklets_window[j].ifr
        temp_Tracklets_window.end_time = Tracklets_window[j].last_update
        window_trk_tail.append(temp_Tracklets_window)

    thr = param.obs_thr
    print(1111)
    score_trk = mot_eval_association_matrix(window_trk_head, window_trk_tail,
                                            param, 'Trk', ILDA)
    print(score_trk, "score_trk matrix:")
    matching, Affinity = mot_association_hungarian(score_trk, thr)
    alpha = param.alpha
    rm_idx = []
    print(matching, "matching matrix:")
    #association the tracklet in the window to init tracklets
    for m in range(0, len(Affinity)):
        head_idx = head_index[matching[0, m]]
        tail_idx = tail_index[matching[1, m]]
        print(
            "concat the tracklets whose ids is {} and {}".format(
                head_idx, tail_idx), "----" * 30)
        fr1 = Tracklets_window[tail_idx].ifr
        fr2 = Tracklets_window[tail_idx].last_update
        for kk in range(fr1, fr2):
            ListInsert(Tracklets_window[head_idx].state, kk,
                       Tracklets_window[tail_idx].state[kk], [])
        numHyp = len(Tracklets_window[tail_idx].hyp.score)
        #copy hyp information from window_tracklets to init_tracklets
        for kk in range(fr1, numHyp):
            mot_tracklets_concat(Tracklets_window[head_idx],
                                 Tracklets_window[tail_idx], kk, param)
        mot_check_idsw(Tracklets_window[head_idx])
        XX = np.array([0, 0, 0, 0])
        numState = len(Tracklets_window[head_idx].state)
        XX[0] = Tracklets_window[head_idx].state[fr1][0]
        XX[2] = Tracklets_window[head_idx].state[fr1][1]
        PP = param.P
        Tracklets_window[head_idx].type = 'High'
        mot_appearance_model_update(Tracklets_window[head_idx], param)
        rm_idx.append(tail_idx)
    if len(rm_idx) != 0:
        print("removed tracklets ids of which are {}".format(rm_idx))
        for idx in sorted(rm_idx, reverse=True):
            Tracklets_window.pop(idx)

    return Tracklets_window, Obs_grap_window
def mot_tracklets_components_setup(img=None,
                                   Trk=None,
                                   detections=None,
                                   cfr=None,
                                   ass_idx=None,
                                   param=None,
                                   tmp_label=None,
                                   Obs_grap=None,
                                   *args,
                                   **kwargs):
    #ass_idx the tracklet state
    nofa = len(np.where(np.array(ass_idx) != -1)[0])
    #record the detections id which refer to the object
    ystate_id_list = [-1] * cfr
    tracklet = Tracklet()  #genenrate a new tracklet
    tracklet.Conf_prob = param.init_prob
    tracklet.type = 'High'
    tracklet.reliable = 'False'
    tracklet.isnew = 1
    tracklet.sub_img = []
    tracklet.status = 'none'
    tracklet.hyp.score = []

    tracklet.ifr = cfr - nofa
    tracklet.efr = 0
    tracklet.last_update = cfr - 1
    tracklet.window_end = cfr - 1
    Acc_tmpl = np.zeros(((param.Bin * 3), param.subregion))
    A_Model_list = [None] * (cfr - nofa)
    #from crruent frame to  track the len(ass_idx) privious frames detection
    for i in range(0, nofa):
        state = np.array((4))
        tmp_idx = cfr - i - 1
        temp_state = np.array(
            detections[tmp_idx][ass_idx[tmp_idx]][2:6].copy())
        temp_affinity = Obs_grap[tmp_idx].child_A_Model_affinity[
            ass_idx[tmp_idx]]
        ystate_id_list.append(detections[tmp_idx][ass_idx[tmp_idx]][1])
        ListInsert(tracklet.hyp.score, tmp_idx, temp_affinity, 0)
        ListInsert(tracklet.state, tmp_idx, temp_state, [])
        ListInsert(tracklet.detections_id_list, tmp_idx, ass_idx[tmp_idx],
                   None)
        tmpl = mot_appearance_model_generation(img[tmp_idx], param, temp_state,
                                               False).squeeze()
        A_Model_list.append(tmpl)
    tracklet.A_model_list = A_Model_list
    ystate_id_list.reverse()

    # Appearnce Model
    tracklet.A_Model = Acc_tmpl / nofa
    # Forward Motion Model
    # XX [4,frames]
    XX, PP = mot_motion_model_generation(tracklet, param, 'Forward')
    lt = XX.shape[1]
    tracklet.FMotion.X = np.zeros((4, cfr))
    tracklet.FMotion.P = np.zeros((4, 4, cfr))
    tracklet.FMotion.X[:, cfr - lt:] = XX
    tracklet.FMotion.P[:, :, cfr - lt:] = PP
    tracklet.BMotion.X = []
    tracklet.BMotion.P = []
    tracklet.hyp.ystates_id = [0] * cfr
    tracklet.hyp.ystate = [item for item in tracklet.state]
    tracklet.hyp.ystates_id = ystate_id_list

    mot_check_idsw(tracklet)
    mot_get_label(Trk, tracklet, param)
    Trk.append(tracklet)
    #count the number of the total tracklets
    param.total_tracklet_count += 1
    if (tracklet.window_end - tracklet.ifr + 1) > 5:
        mot_tracklet_confidence_update(tracklet, param, param.lambda_)
    mot_appearance_model_update(tracklet, param)

    #label the used detections as -1 in iso_idx and child
    used_idx = []
    nT = len(np.where(np.array(ass_idx) != -1)[0])
    for hh in range(0, nT):
        h = -nT + hh
        used_idx.append(ass_idx[h])
    for i in range(0, len(used_idx)):
        iden = used_idx[i]
        Obs_grap[cfr + i - nT].iso_idx[iden] = -1
        Obs_grap[cfr + i - nT].child[iden] = -1

    print("Window Tracklet Generated:len(Trk_Window)+1", ass_idx[-nofa - 2:])
    return Trk, param
def mot_tracklets_components_setup(img=None,
                                   Trk=None,
                                   detections=None,
                                   cfr=None,
                                   y_idx=None,
                                   param=None,
                                   tmp_label=None,
                                   initTracklet=False,
                                   *args,
                                   **kwargs):
    #y_idx the tracklet state
    ass_idx = y_idx
    nofa = len(np.where(np.array(y_idx) != -1)[0])
    #record the detections id which refer to the object
    ystate_id_list = []
    tracklet = Tracklet()  #genenrate a new tracklet
    tracklet.Conf_prob = param.init_prob
    tracklet.type = 'High'
    tracklet.reliable = 'False'
    tracklet.isnew = 1
    tracklet.sub_img = []
    tracklet.status = 'none'
    if tmp_label != None:
        tracklet.label = tmp_label
    else:
        param, idx = Labelling(param)
        tracklet.label = idx

    tracklet.ifr = cfr - nofa
    tracklet.efr = 0
    tracklet.last_update = cfr - 1
    Acc_tmpl = np.zeros(((param.Bin * 3), param.subregion))
    for i in range(
            0, nofa
    ):  #from crruent frame to  track the len(ass_idx) privious frames detections
        state = np.array((4))
        tmp_idx = cfr - i - 1
        temp_state = np.array(
            detections[tmp_idx][ass_idx[tmp_idx][0]][2:6].copy())
        ystate_id_list.append(detections[tmp_idx][ass_idx[tmp_idx][0]][1])
        ListInsert(tracklet.state, tmp_idx, temp_state, [])
        #tracklet.state.append(temp_state)
        #tracklet.state[tmp_idx][3,1]=detections(tmp_idx).h(ass_idx(tmp_idx))
        tmpl = mot_appearance_model_generation(img[tmp_idx], param, temp_state,
                                               False)
        Acc_tmpl = Acc_tmpl + tmpl.squeeze()[:, np.newaxis]

    ystate_id_list.reverse()

    # Appearnce Model
    tracklet.A_Model = Acc_tmpl / nofa
    # Forward Motion Model
    # XX [4,frames]
    XX, PP = mot_motion_model_generation(tracklet, param, 'Forward', nargout=2)
    lt = XX.shape[1]
    tracklet.FMotion.X = np.zeros((4, cfr))
    tracklet.FMotion.P = np.zeros((4, 4, cfr))
    tracklet.FMotion.X[:, cfr - lt:] = XX
    tracklet.FMotion.P[:, :, cfr - lt:] = PP
    tracklet.BMotion.X = []
    tracklet.BMotion.P = []
    tracklet.hyp.score = [0] * cfr
    tracklet.hyp.ystate = [item for item in tracklet.state]
    tracklet.hyp.ystates_ids = ystate_id_list
    Trk.append(tracklet)
    #count the number of the total tracklets
    param.total_tracklet_count += 1
    return Trk, param