コード例 #1
0
ファイル: group.py プロジェクト: d-val/TFM
def checkoverlap(x1, y1, r1, x2, y2, r2):

    dxy = np.sqrt(np.power(y2 - y1, 2) + np.power(x2 - x1, 2))
    dr = np.power(r2 + r1, 2)

    if dxy <= dr:
        return True

    else:
        return False
コード例 #2
0
def checkoverlap(x1, y1, r1, x2, y2, r2):

    dxy = np.sqrt(np.power(y2 - y1, 2) + np.power(x2 - x1, 2))
    dr = np.power(r2 + r1, 2)

    if dxy <= dr:
        return True

    else:
        return False
コード例 #3
0
ファイル: track.py プロジェクト: misaelzapata/TFM
    def calculatesubjectdistance(self, subject, threshold):  # Future change

        (xt, yt), radius = self.subject.circle
        (xs, ys), radius = subject.circle

        loss = int(np.sqrt(np.power(xt - xs, 2) + np.power(yt - ys, 2)))

        if loss <= threshold:
            return True
        else:
            return False
コード例 #4
0
ファイル: track.py プロジェクト: lacatus/TFM
    def calculatesubjectdistance(self, subject, threshold):  # Future change

        (xt, yt), radius = self.subject.circle
        (xs, ys), radius = subject.circle

        loss = int(np.sqrt(np.power(xt - xs, 2) + np.power(yt - ys, 2)))
        print 'Deassociate loss'
        print loss
        if loss <= threshold:
            return True
        else:
            return False
コード例 #5
0
ファイル: association.py プロジェクト: d-val/TFM
def lossfunction__old1(tr, sub):
    #@Borja(orginal)1

    # Where to create the loss using data from the subject class

    # First simple loss function---------------------------------------
    # Based in simple distance to subject base
    (xt, yt), radius = tr.pf.circle
    (xs, ys), radius = sub.circle

    distance = int(np.sqrt(np.power(xt - xs, 2) + np.power(yt - ys, 2)))

    # Second loss function---------------------------------------------
    # Based in normal probability density function of particles for
    # position and detection size

    (x, y), (h, w), a = sub.rot_box

    p = tr.pf.p
    p_star = tr.pf.p_star
    p_mean = tr.pf.p_mean

    # optimizacion --> no calcular constantemente mean y std, sino hacerlo antes de entrar aqui
    # loss = -x -y -vx -vy
    loss  = - np.log(normpdf(x, np.mean(p[:, 0]), np.std(p[:, 0]))) \
        - np.log(normpdf(y, np.mean(p[:, 1]), np.std(p[:, 1]))) \
        - np.log(normpdf(x - p_star[0], np.mean(p[:, 4]), np.std(p[:, 4]))) \
        - np.log(normpdf(y - p_star[1], np.mean(p[:, 5]), np.std(p[:, 5]))) 
        #- np.log(normpdf(sub.h, np.mean(p[:, 4]), np.std(p[:, 4])))

    debug_flag=0
    if debug_flag:
        """
        print '###'
        print normpdf(p_star[1] - y, np.mean(p[:, 5]), np.std(p[:, 5]))
        print x
        print y
        """

        """
        print '----'
        print 'x, y, h: %s, %s, %s' % (x, y, sub.h)
        #print 'x: %s' % - np.log(normpdf(x, np.mean(p[:, 0]), np.std(p[:, 0])))
        print 'vx: %s' % - np.log(normpdf(p_star[0] - x, np.mean(p[:, 4]), np.std(p[:, 4])))
        print 'vy: %s' % - np.log(normpdf(p_star[1] - y, np.mean(p[:, 5]), np.std(p[:, 5])))
        print '----'
        """

    return loss, distance
コード例 #6
0
def lossfunction__old1(tr, sub):
    #@Borja(orginal)1

    # Where to create the loss using data from the subject class

    # First simple loss function---------------------------------------
    # Based in simple distance to subject base
    (xt, yt), radius = tr.pf.circle
    (xs, ys), radius = sub.circle

    distance = int(np.sqrt(np.power(xt - xs, 2) + np.power(yt - ys, 2)))

    # Second loss function---------------------------------------------
    # Based in normal probability density function of particles for
    # position and detection size

    (x, y), (h, w), a = sub.rot_box

    p = tr.pf.p
    p_star = tr.pf.p_star
    p_mean = tr.pf.p_mean

    # optimizacion --> no calcular constantemente mean y std, sino hacerlo antes de entrar aqui
    # loss = -x -y -vx -vy
    loss  = - np.log(normpdf(x, np.mean(p[:, 0]), np.std(p[:, 0]))) \
        - np.log(normpdf(y, np.mean(p[:, 1]), np.std(p[:, 1]))) \
        - np.log(normpdf(x - p_star[0], np.mean(p[:, 4]), np.std(p[:, 4]))) \
        - np.log(normpdf(y - p_star[1], np.mean(p[:, 5]), np.std(p[:, 5])))
    #- np.log(normpdf(sub.h, np.mean(p[:, 4]), np.std(p[:, 4])))

    debug_flag = 0
    if debug_flag:
        """
        print '###'
        print normpdf(p_star[1] - y, np.mean(p[:, 5]), np.std(p[:, 5]))
        print x
        print y
        """
        """
        print '----'
        print 'x, y, h: %s, %s, %s' % (x, y, sub.h)
        #print 'x: %s' % - np.log(normpdf(x, np.mean(p[:, 0]), np.std(p[:, 0])))
        print 'vx: %s' % - np.log(normpdf(p_star[0] - x, np.mean(p[:, 4]), np.std(p[:, 4])))
        print 'vy: %s' % - np.log(normpdf(p_star[1] - y, np.mean(p[:, 5]), np.std(p[:, 5])))
        print '----'
        """

    return loss, distance
コード例 #7
0
ファイル: particlefilter.py プロジェクト: misaelzapata/TFM
    def plikelihood(self):

        (x, y), (h, w), a = self.det
        det = np.floor(np.array([[x, y, h, w]]))
        yrep = np.ones((self.num_p, 4)) * det

        R2 = np.sum(np.power(self.p - yrep, 2), 1)
        width = 2 * (np.amax(np.sqrt(R2)) - np.amin(np.sqrt(R2)))
        prob = np.exp(-R2 / width)

        prob = prob / np.sum(prob)
        self.prob = prob

        self.sortprob()
コード例 #8
0
ファイル: particlefilter.py プロジェクト: d-val/TFM
    def plikelihood(self):

        if self.update:
            (x, y), (h, w), a = self.rb

            det = np.floor(np.array([[x, y, h, w, x - self.p_star[0], y - self.p_star[1]]]))
            yrep = np.ones((self.num_p, 6)) * det

            R2 = np.sum(np.power(self.p[:, 0:6] - yrep, 2), 1)
            width = 2 * (np.amax(np.sqrt(R2)) - np.amin(np.sqrt(R2)))
            prob = np.exp(- R2 / width)

            a = np.sum(prob)
            if a != 0.0:
                prob = prob / np.sum(prob)
            self.prob = prob

            self.sortprob()
        self.calculatepstar()
コード例 #9
0
ファイル: particlefilter.py プロジェクト: gelansheshed/TFM
    def plikelihood(self):

        if self.update:
            (x, y), (h, w), a = self.rb

            det = np.floor(
                np.array([[x, y, h, w, x - self.p_star[0],
                           y - self.p_star[1]]]))
            yrep = np.ones((self.num_p, 6)) * det

            R2 = np.sum(np.power(self.p[:, 0:6] - yrep, 2), 1)
            width = 2 * (np.amax(np.sqrt(R2)) - np.amin(np.sqrt(R2)))
            prob = np.exp(-R2 / width)

            a = np.sum(prob)
            if a != 0.0:
                prob = prob / np.sum(prob)
            self.prob = prob

            self.sortprob()
        self.calculatepstar()
コード例 #10
0
ファイル: particlefilter.py プロジェクト: d-val/TFM
    def plikelihood_new(self):

        if self.update:
            (x, y), (h, w), a = self.rb


            detectionExtended = np.floor(np.array([[x, y, h, w, x - self.p_star[0], y - self.p_star[1]]]))
            yrep = np.ones((self.num_p, 6)) * detectionExtended
            prob = gaussMixModelPDF(oneParticle,detectionExtended,p_star)


            R2 = np.sum(np.power(self.p[:, 0:6] - yrep, 2), 1)
            width = 2 * (np.amax(np.sqrt(R2)) - np.amin(np.sqrt(R2)))
            prob = np.exp(- R2 / width)

            a = np.sum(prob)

            if a != 0.0:
                prob = prob / np.sum(prob)
            self.prob = prob

            self.sortprob()
            self.calculatepstar()
コード例 #11
0
ファイル: particlefilter.py プロジェクト: gelansheshed/TFM
    def plikelihood_new(self):

        if self.update:
            (x, y), (h, w), a = self.rb

            detectionExtended = np.floor(
                np.array([[x, y, h, w, x - self.p_star[0],
                           y - self.p_star[1]]]))
            yrep = np.ones((self.num_p, 6)) * detectionExtended
            prob = gaussMixModelPDF(oneParticle, detectionExtended, p_star)

            R2 = np.sum(np.power(self.p[:, 0:6] - yrep, 2), 1)
            width = 2 * (np.amax(np.sqrt(R2)) - np.amin(np.sqrt(R2)))
            prob = np.exp(-R2 / width)

            a = np.sum(prob)

            if a != 0.0:
                prob = prob / np.sum(prob)
            self.prob = prob

            self.sortprob()
            self.calculatepstar()
コード例 #12
0
ファイル: association.py プロジェクト: d-val/TFM
def lossfunction(tr, sub):
    #@CIA june-25-2015

    loss=0
    distance=0
    #----prepare variables
    (x, y), (h, b), a = sub.rot_box
    p = tr.pf.p
    p_star = tr.pf.p_star
    p_mean = tr.pf.p_mean

    #----obtain loss(tr,sub)
    #--distance(tr,sub)
    sqDistance = np.power(x - p_mean[0], 2) + np.power(y - p_mean[1], 2)
    distance = np.sqrt(sqDistance)
    #--mix of gaussians
    w_star = 0.20
    w_mean = 0.80
    #sigma_mean = 1
    #sigma_star = 1

    """
    TODO
    ----
    cov --> anchura de las particulas en vez de 1
    """

    """
    COLOR_CUBES
    ---
    1 vector de 8 cubos por canal de color BGR
    ---
    SUBJECT (Deteccion)
    b, g, r = sub.rgb_cubes
    TRACKER
    b, g, r = tr.rgb_cubes
    """

    #.for X
    mu_starX = p_star[0] # x_star
    mu_meanX = p_mean[0] # x_mean
    sigma_starX = p_star[3]#/2
    sigma_meanX = p_mean[3]#/2
    lossX = w_star*norm.pdf(x,mu_starX,sigma_starX) + w_mean*norm.pdf(x,mu_meanX,sigma_meanX)
    #.for Y
    mu_starY = p_star[1] # x_star
    mu_meanY = p_mean[1] # x_mean
    sigma_starY = p_star[2]#/2
    sigma_meanY = p_mean[2]#/2
    lossY = w_star*norm.pdf(y,mu_starY,sigma_starY) + w_mean*norm.pdf(y,mu_meanY,sigma_meanY)    #.neglog of joint(X,Y) assuming independence

    # For appareance

    lossApp = cv2.compareHist(tr.rgb_cubes.ravel().astype('float32'),
                          sub.rgb_cubes.ravel().astype('float32'),
                          cv2.cv.CV_COMP_BHATTACHARYYA)
    #print cv2.normalize(sub.rgb_cubes.ravel().astype('float32'))
    #print cv2.normalize(tr.rgb_cubes.ravel().astype('float32'))
    
    loss = - np.log(lossX) - np.log(lossY) + np.log(lossApp)

    if loss == float('Inf') or loss == -float('Inf'):
        loss = 100
    return loss, distance
コード例 #13
0
ファイル: association.py プロジェクト: d-val/TFM
def normpdf(x, m, v):
    
    return (1 / (np.sqrt(2 * np.pi) * v)) * np.exp(-(1./2) * np.power((x - m) / v, 2))
コード例 #14
0
def lossfunction(tr, sub):
    #@CIA june-25-2015

    loss = 0
    distance = 0
    #----prepare variables
    (x, y), (h, b), a = sub.rot_box
    p = tr.pf.p
    p_star = tr.pf.p_star
    p_mean = tr.pf.p_mean

    #----obtain loss(tr,sub)
    #--distance(tr,sub)
    sqDistance = np.power(x - p_mean[0], 2) + np.power(y - p_mean[1], 2)
    distance = np.sqrt(sqDistance)
    #--mix of gaussians
    w_star = 0.20
    w_mean = 0.80
    #sigma_mean = 1
    #sigma_star = 1
    """
    TODO
    ----
    cov --> anchura de las particulas en vez de 1
    """
    """
    COLOR_CUBES
    ---
    1 vector de 8 cubos por canal de color BGR
    ---
    SUBJECT (Deteccion)
    b, g, r = sub.rgb_cubes
    TRACKER
    b, g, r = tr.rgb_cubes
    """

    #.for X
    mu_starX = p_star[0]  # x_star
    mu_meanX = p_mean[0]  # x_mean
    sigma_starX = p_star[3]  #/2
    sigma_meanX = p_mean[3]  #/2
    lossX = w_star * norm.pdf(x, mu_starX, sigma_starX) + w_mean * norm.pdf(
        x, mu_meanX, sigma_meanX)
    #.for Y
    mu_starY = p_star[1]  # x_star
    mu_meanY = p_mean[1]  # x_mean
    sigma_starY = p_star[2]  #/2
    sigma_meanY = p_mean[2]  #/2
    lossY = w_star * norm.pdf(y, mu_starY, sigma_starY) + w_mean * norm.pdf(
        y, mu_meanY, sigma_meanY)  #.neglog of joint(X,Y) assuming independence

    # For appareance

    lossApp = cv2.compareHist(tr.rgb_cubes.ravel().astype('float32'),
                              sub.rgb_cubes.ravel().astype('float32'),
                              cv2.cv.CV_COMP_BHATTACHARYYA)
    #print cv2.normalize(sub.rgb_cubes.ravel().astype('float32'))
    #print cv2.normalize(tr.rgb_cubes.ravel().astype('float32'))

    loss = -np.log(lossX) - np.log(lossY) + np.log(lossApp)

    if loss == float('Inf') or loss == -float('Inf'):
        loss = 100
    return loss, distance
コード例 #15
0
def normpdf(x, m, v):

    return (1 / (np.sqrt(2 * np.pi) * v)) * np.exp(-(1. / 2) * np.power(
        (x - m) / v, 2))