Example #1
0
def N12Frag(As):
	A = Fragment()
	sizeA = len(As.points)
	A.points = np.empty([1,sizeA,2],np.int)
	for i in range(0,sizeA):
		A.points[0][i] = As.points[i]
	A.turning_angles = As.turning_angles
	A.images = As.images
	return A
Example #2
0
def getTransformedFragment(A,T):
	if(T == None):
		return None
	B = Fragment()
	(dummy1,sizeA,dummy2) = A.points.shape
	B.points = np.empty([1,sizeA,2],np.int)
	B.images = 0
	B.turning_angles = 0
	for i in range(0,sizeA):
		B.points[0][i] = A.points[0][i]
	transformCountour(B.points,T,config.NORMALNUMPY)
	return B
Example #3
0
 def fragment_io(self):
     io_data = []
     for fragment in self.FragmentData:
         frag_object = Fragment(fragment)
         if frag_object.status == True:
             io_data.append(frag_object)
     return(io_data)
Example #4
0
def N12Frag(As):
    A = Fragment()
    sizeA = len(As.points)
    A.points = np.empty([1, sizeA, 2], np.int)
    for i in range(0, sizeA):
        A.points[0][i] = As.points[i]
    A.turning_angles = As.turning_angles
    A.images = As.images
    return A
Example #5
0
def getTransformedFragment(A, T):
    if (T == None):
        return None
    B = Fragment()
    (dummy1, sizeA, dummy2) = A.points.shape
    B.points = np.empty([1, sizeA, 2], np.int)
    B.images = 0
    B.turning_angles = 0
    for i in range(0, sizeA):
        B.points[0][i] = A.points[0][i]
    transformCountour(B.points, T, config.NORMALNUMPY)
    return B
Example #6
0
def getMergedFragment(A, B, startA, endA, startB, endB, flag):
    # print "WE ARE HERE"
    # print "startA = ",startA,"endA = ",endA,"startB = ",startB,"endB = ",endB
    print "\nIMAGES IN A = ", len(A.images)
    print "\nIMAGES IN B = ", len(B.images)
    T = getTransformationMatirxFromFragment(B, A, startB, endB, startA, endA,
                                            config.FRAGMENT)
    if (T is None):
        return None


# 	print T
    dummy1, sizeA, dummy2 = A.points.shape
    dummy1, sizeB, dummy2 = B.points.shape

    if (flag == config.ENHANCEMODE):
        startA, endA, startB, endB = findProperStartAndEndPoint(
            A, B, startA, endA, startB, endB, T)

    Xnumpy = np.empty([1, sizeA + sizeB + 2, 2], np.int)
    X = Xnumpy[0]
    contourA = A.points[0]
    contourB = B.points[0]

    j = 0
    if (endA > startA and endB > startB):
        # print "FIRST CASE"
        for i in range(0, startA + 1):
            X[j] = contourA[i]
            j = j + 1
        for i in range(startB - 1, -1, -1):
            P = getTransformedPoint(T, contourB[i])
            X[j] = P
            j = j + 1
        for i in range(sizeB - 1, endB - 1, -1):
            P = getTransformedPoint(T, contourB[i])
            X[j] = P
            j = j + 1
        for i in range(endA + 1, sizeA):
            X[j] = contourA[i]
            j = j + 1
    if (endA > startA and endB < startB):
        # print "2nd CASE"
        for i in range(0, startA):
            X[j] = contourA[i]
            j = j + 1
        for i in range(startB, sizeB):
            P = getTransformedPoint(T, contourB[i])
            X[j] = P
            j = j + 1
        for i in range(0, endB):
            P = getTransformedPoint(T, contourB[i])
            X[j] = P
            j = j + 1
        for i in range(endA, sizeA):
            X[j] = contourA[i]
            j = j + 1
    if (endA < startA and endB > startB):
        # print "3rd CASE"
        for i in range(0, endA + 1):
            X[j] = contourA[i]
            j = j + 1
        for i in range(endB + 1, sizeB):
            P = getTransformedPoint(T, contourB[i])
            X[j] = P
            j = j + 1
        for i in range(0, startB):
            P = getTransformedPoint(T, contourB[i])
            X[j] = P
            j = j + 1
        for i in range(startA, sizeA):
            X[j] = contourA[i]
            j = j + 1
    if (endA < startA and endB < startB):
        # print "4th CASE"
        for i in range(0, endA):
            X[j] = contourA[i]
            j = j + 1
        for i in range(endB - 1, -1, -1):
            P = getTransformedPoint(T, contourB[i])
            X[j] = P
            j = j + 1
        for i in range(sizeB - 1, startB, -1):
            P = getTransformedPoint(T, contourB[i])
            X[j] = P
            j = j + 1
        for i in range(startA, sizeA):
            X[j] = contourA[i]
            j = j + 1
    # now j is the number of points on the new contour

    F = Fragment()
    F.points = np.empty([1, j, 2], np.int)
    for i in range(0, j):
        F.points[0][i] = X[i]
    F.images = []

    for i in range(0, len(A.images)):
        image = Image()
        image.name = A.images[i].name
        image.transform_matrix = A.images[i].transform_matrix
        print "\nMatrix ", i, " (A)", "\n"
        print image.transform_matrix
        F.images.append(image)

    for i in range(0, len(B.images)):
        image = Image()
        image.name = B.images[i].name
        image.transform_matrix = T * (B.images[i].transform_matrix)
        print "\nMatrix ", i, " (B)", "\n"
        print image.transform_matrix
        F.images.append(image)
    print "\nIMAGES IN F = ", len(F.images)
    return F
Example #7
0
	'/home/anthill/fzheng/home/searchDB/bc-30-sc-20141022-newpds/list'])

ldir = General.createLocalSpace()
odir = os.getcwd()
errorfree = True

smart = False
if args.rmsd == None:
	smart = True
else:
	rmsdeff = args.rmsd

for pdb in args.p:
	# set rmsd cutoff using Craig's function
	residues = PDB.ConRes(pdb)
	segments = Fragment.getSegments(residues)
	if smart:
		rmsdeff = mustpress.rmsdEff(segments, args.params[0], args.params[1])

	seqout = args.head + '_' + General.changeExt(pdb, 'seq')
	matchout = General.changeExt(seqout, 'match')

	if os.path.isfile(seqout):
		continue

	# search is additonal to a previous round
	if args.more != None:
		oseqf = args.more + '_' + General.changeExt(pdb, 'seq')
		if not os.path.isfile(oseqf):
			continue
		olen = sum([1 for x in open(oseqf)])
Example #8
0
def CompareContour(F1,F2):
    global sequence1,sequence2,scoreTable,traceBack,traceBack1
    sequence1=F1.turning_angles
    sequence2=F2.turning_angles[::-1]
    
    
    print(sequence1)
    print(sequence2)
    
    # print("sequence1")
    # print(sequence1)
    # print("sequence2")
    # print(sequence2)

    l1=len(sequence1)+1
    l2=len(sequence2)+1
    
    
    initialize(l1,l2)
    fillIn(l1,l2)
    
    start_end=getTraceback(F1.points,F2.points[::-1],F1.turning_angles,F2.turning_angles[::-1])
    
    match= Matchset()
    match_1=Fragment()
    match_2=Fragment()
    lt=len(traceBack)
    match_1.points=get1N2(traceBack)
    match_2.points=get1N2(traceBack1)
    
    FF1=Fragment()
    FF2=Fragment()
    
    
    FF1.points=get1N2(F1.points)
    FF1.turning_angles=F1.turning_angles
    FF2.points=get1N2(F2.points)
    FF2.turning_angles=F2.turning_angles

    FF1.images = []
    FF2.images = []



    for i in range(0,len(F1.images)):
        image = Image()
        image.name = F1.images[i].name
        image.transform_matrix = getIdentitymatrix() * F1.images[i].transform_matrix
        FF1.images.append(image)

    for i in range(0,len(F2.images)):
        image = Image()
        image.name = F2.images[i].name
        image.transform_matrix = getIdentitymatrix() * F2.images[i].transform_matrix
        FF2.images.append(image)
    
    
    match.fragment_1=FF1
    match.fragment_2=FF2
    match.match_1=match_1
    match.match_2=match_2
    match.score=highScoreCell.score
    match.match_1_start=start_end[0]
    match.match_2_start=l2-start_end[1]+1
    match.match_1_end=start_end[2]
    match.match_2_end=l2-start_end[3]+1
    
    
    
    
    contour_img=np.zeros((1000,1000,1), np.uint8)
    contour_img1=np.zeros((1000,1000,1), np.uint8)
    
    #traceBack=cv2.approxPolyDP(traceBack,2,True)
    
    lt=len(traceBack1)
    #displayContour("TraceBack"+str(lt),traceBack)
    #displayContour("TraceBack1"+str(lt),traceBack1)

    #cv2.drawContours(contour_img, traceBack, -1, 255, 1)
    #cv2.drawContours(contour_img1, traceBack1, -1, 255, 1)
    
    #displayContour("Match1",traceBack)
    #displayContour("Match2",traceBack1)
    
    
    # cv2.imshow('IMPORTANT !!! :D',contour_img)
    # cv2.imshow('IMPORTANT2 !!! :D',contour_img1)
    
#     print("Length 1")
#     print(len(traceBack1))
#     print("Length 2")
#     print(len(traceBack))
#     


    contour_img=np.zeros((1000,1000),np.uint8)

    #cv2.drawContours(contour_img,np.array(traceBack),-1,255,1)

    return match
Example #9
0
def getMergedFragment(A,B,startA,endA,startB,endB,flag):
	# print "WE ARE HERE"
	# print "startA = ",startA,"endA = ",endA,"startB = ",startB,"endB = ",endB
	print "\nIMAGES IN A = ",len(A.images)
	print "\nIMAGES IN B = ",len(B.images)
	T = getTransformationMatirxFromFragment(B,A,startB,endB,startA,endA,config.FRAGMENT)
	if(T is None):
		return None
	
# 	print T
	dummy1,sizeA,dummy2 = A.points.shape
	dummy1,sizeB,dummy2 = B.points.shape

	if(flag == config.ENHANCEMODE):
		startA,endA,startB,endB = findProperStartAndEndPoint(A,B,startA,endA,startB,endB,T)

	Xnumpy = np.empty([1,sizeA+sizeB+2,2],np.int)
	X = Xnumpy[0]
	contourA = A.points[0]
	contourB = B.points[0]

	j = 0
	if(endA > startA and endB > startB):
		# print "FIRST CASE"
		for i in range(0,startA+1):
			X[j] = contourA[i]
			j = j+1
		for i in range(startB-1,-1,-1):
			P = getTransformedPoint(T,contourB[i])
			X[j] = P
			j = j + 1
		for i in range(sizeB-1,endB-1,-1):
			P = getTransformedPoint(T,contourB[i])
			X[j] = P
			j = j + 1
		for i in range(endA+1,sizeA):
			X[j] = contourA[i]
			j = j+1
	if(endA > startA and endB < startB):
		# print "2nd CASE"
		for i in range(0,startA):
			X[j] = contourA[i]
			j = j+1
		for i in range(startB,sizeB):
			P = getTransformedPoint(T,contourB[i])
			X[j] = P
			j = j + 1
		for i in range(0,endB):
			P = getTransformedPoint(T,contourB[i])
			X[j] = P
			j = j + 1
		for i in range(endA,sizeA):
			X[j] = contourA[i]
			j = j+1
	if(endA < startA and endB > startB):
		# print "3rd CASE"
		for i in range(0,endA+1):
			X[j] = contourA[i]
			j = j+1
		for i in range(endB+1,sizeB):
			P = getTransformedPoint(T,contourB[i])
			X[j] = P
			j = j + 1
		for i in range(0,startB):
			P = getTransformedPoint(T,contourB[i])
			X[j] = P
			j = j + 1
		for i in range(startA,sizeA):
			X[j] = contourA[i]
			j = j+1
	if(endA < startA and endB < startB):
		# print "4th CASE"
		for i in range(0,endA):
			X[j] = contourA[i]
			j = j+1
		for i in range(endB-1,-1,-1):
			P = getTransformedPoint(T,contourB[i])
			X[j] = P
			j = j + 1
		for i in range(sizeB-1,startB,-1):
			P = getTransformedPoint(T,contourB[i])
			X[j] = P
			j = j + 1
		for i in range(startA,sizeA):
			X[j] = contourA[i]
			j = j+1
	# now j is the number of points on the new contour
	
	F = Fragment()
	F.points = np.empty([1,j,2],np.int)
	for i in range(0,j):
		F.points[0][i] = X[i]
	F.images = []
	
	for i in range(0,len(A.images)):
		image = Image()
		image.name = A.images[i].name
		image.transform_matrix = A.images[i].transform_matrix
		print "\nMatrix ",i," (A)","\n"
		print image.transform_matrix
		F.images.append(image)

	for i in range(0,len(B.images)):
		image = Image()
		image.name = B.images[i].name
		image.transform_matrix = T * ( B.images[i].transform_matrix )
		print "\nMatrix ",i," (B)","\n"
		print image.transform_matrix
		F.images.append(image)
	print "\nIMAGES IN F = ",len(F.images)
	return F
def computeContacts(mut, contacts, denominator_cons, denominator_cen, outf):
    # for each contact, compute two separated values for wild type and mutant
    contacts_keys = [x for x in contacts.keys() if x.split(",")[1].isdigit()]
    contacts_keys = sorted(contacts_keys, key=lambda x: int(x.split(",")[1]))
    idx = 1
    outfh = open(outf, "w")
    normal_cmap = args.sdir + "/" + mut.p.lower() + ".clean.cmap"

    for con in contacts_keys:
        numerator_w = sum([float(x.split()[1]) for x in contacts[con] if x.split()[0] == mut.w])
        numerator_m = sum([float(x.split()[1]) for x in contacts[con] if x.split()[0] == mut.m])
        if numerator_w == 0:
            contactdegree_w = 0
        else:
            denominator_cen_w = [x for x in denominator_cen if x.split()[0] == PDB.s2t(mut.w)][0].split()[1:]
            denominator_con = denominator_cons[con].split()[1:]
            denominator_w = 0
            for p1, p2 in itertools.product(denominator_cen_w[1:], denominator_con[1:]):
                denominator_w += float(p1) * float(p2)
            denominator_w *= float(denominator_cen_w[0]) * float(denominator_con[0])
            contactdegree_w = numerator_w / denominator_w
        if numerator_m == 0:
            contactdegree_m = 0
        else:
            denominator_cen_m = [x for x in denominator_cen if x.split()[0] == PDB.s2t(mut.m)][0].split()[1:]
            denominator_con = denominator_cons[con].split()[1:]
            denominator_m = 0
            for p1, p2 in itertools.product(denominator_cen_m[1:], denominator_con[1:]):
                denominator_m += float(p1) * float(p2)
            denominator_m *= float(denominator_cen_m[0]) * float(denominator_con[0])
            contactdegree_m = numerator_m / denominator_m
        contactdegree_w, contactdegree_m = format(contactdegree_w, ".4f"), format(contactdegree_m, ".4f")

        # also add normal contact degree between these two position:
        normal_cond = Fragment.getConD(normal_cmap, mut.c + "," + str(mut.n), con)
        normal_cond = format(normal_cond, ".4f")

        outstring = (
            "\t".join(
                map(
                    str,
                    [
                        idx,
                        mut.p,
                        mut.c + "," + str(mut.n),
                        con,
                        contactdegree_w,
                        contactdegree_m,
                        normal_cond,
                        denominator_cons[con].split()[0],
                    ],
                )
            )
            + "\n"
        )
        idx += 1
        outfh.write(outstring)

        # there could be some contacts which are not detected by two side chains
    normal_cons, normal_conress = Fragment.contactList(normal_cmap, mut.c, mut.n, dcut=0.01)
    for k in range(len(normal_cons)):
        if normal_cons[k] in contacts_keys:  # already indexed contact
            continue
        else:
            normal_cond = Fragment.getConD(normal_cmap, mut.c + "," + str(mut.n), normal_cons[k])
            normal_cond = format(normal_cond, ".4f")
            outstring = (
                "\t".join(
                    map(
                        str,
                        [
                            idx,
                            mut.p,
                            mut.c + "," + str(mut.n),
                            normal_cons[k],
                            0.0000,
                            0.0000,
                            normal_cond,
                            normal_conress[k],
                        ],
                    )
                )
                + "\n"
            )
            idx += 1
            outfh.write(outstring)

            # it would be also nice to have permanent contact, but they are rare and probably captured by environment

    outfh.close()
Example #11
0
def execute(I_List):
    I_List = resizeAllIfNeeded(I_List) # ONLY THIS IS ADDED TO RESIZE
    n_img=len(I_List)

    
    image=[None for i in range(0,n_img)]
    corrected=[None for i in range(0,n_img)]
    kernel = np.ones((1,1),np.uint8)
    contours=[[] for i in range(0,n_img)]
    new_contours=[None for i in range(0,n_img)]
    contour_img=[None for i in range(0,n_img)]
    cont=[None for i in range(0,n_img)]
    turning=[[] for i in range(0,n_img)]
    turn_pts=[[] for i in range(0,n_img)]
    
    F=[]
    


    for i in range(0,n_img):
        imgname = I_List[i]

        imname=imgname[:-4]+str(i)+"temp"
        print(imname)
        image[i]=cv2.imread(imgname,0)
        
        #image[i]=cv2.resize(image[i],(0,0),image[i],0.5,0.5,cv2.INTER_AREA)
        
        color_img=cv2.imread(imgname,1)
        #color_img=cv2.resize(color_img,(0,0),image[i],0.5,0.5,cv2.INTER_AREA)
        
        #image[i]=cv2.GaussianBlur(image[i],(5,5),1)
        print("hell")
        image[i]=cv2.GaussianBlur(image[i],(5,5),1)
        print("helllllo")
        #Image Thresholding
        ret,threshold = cv2.threshold(image[i],THRESHOLD,255,cv2.THRESH_BINARY_INV)
        height,width= image[i].shape[:2]
        src2=np.zeros((height,width,3),np.uint8)
        corrected[i]=cv2.morphologyEx(threshold, cv2.MORPH_CLOSE, kernel)
        open=cv2.morphologyEx(corrected[i], cv2.MORPH_OPEN, kernel)
        iii=cv2.bitwise_and(color_img,color_img,mask=open)
        
        
        #ret,threshold = cv2.threshold(image[i],THRESHOLD,255,cv2.THRESH_BINARY_INV)
        #height,width= image[i].shape[:2]
        # Drawing Contours
        #open=cv2.morphologyEx(threshold, cv2.MORPH_OPEN, kernel)
        #corrected[i]=cv2.morphologyEx(threshold, cv2.MORPH_CLOSE, kernel)
        
        
        if ACCURACY == 1:
            param = cv2.CHAIN_APPROX_TC89_KCOS
        if ACCURACY == 2:
            param = cv2.CHAIN_APPROX_SIMPLE
        if ACCURACY == 3:
            param = cv2.CHAIN_APPROX_NONE
        new_contours[i], hierarchy = cv2.findContours(corrected[i],cv2.RETR_EXTERNAL,param)
        
        
    #     cv2.imshow("Image"+str(i),iii)
        color_img=None
        tempname="TEMP/"+str(i)+str(random.randint(0,100))+".png"
        tempnames.append(tempname)
        cv2.imwrite(tempname,iii)
        #exit()
        # cv2.waitKey(0)
        
        
        # cont1=np.zeros((1000,1000),np.uint8)
        # cv2.drawContours(cont1,new_contours[i],-1,255,1)
        # cv2.imshow("Contour",cont1)
        
        height,width= image[i].shape[:2]
        contour_img[i]=np.zeros((height,width,1), np.uint8)
        
        #displayContour("Cont1",new_contours[i])
        
        #print(new_contours[i])
        for cnt in new_contours[i]:
            if cv2.contourArea(cnt)>MIN_AREA:
                #displayContour("Contq"+str(cv2.contourArea(cnt)),[cnt])
                contours[i].extend(cnt)
        
        
        #contours[i]=contours[i][::1]    
        #contours[i]=cv2.approxPolyDP(new_contours[i][0],2,True)
        
        #contours[i]=[cnt for cnt in contours[i] if cv2.contourArea(cnt)>50000]

        if(len(contours[i])>C_LIMIT):
            contours[i]=contours[i][::int(len(contours[i])/C_LIMIT)]
    
        for num in range(NPOINTS,len(contours[i])-NPOINTS):
            vector1=(contours[i][num-NPOINTS][0]-contours[i][num][0])
            vector2=(contours[i][num+NPOINTS][0]-contours[i][num][0])
            
            #print(vector1)
            
            cos=(vector1[0]*vector2[0]+vector1[1]*vector2[1])/(math.sqrt((math.pow(vector1[0],2)+math.pow(vector1[1],2))*(math.pow(vector2[0],2)+math.pow(vector2[1],2))))
            turn=round(math.acos(cos),100)
            #print(turn)
            #if abs(turn)>=(10*3.14/180) and (abs(turn)<=(170*3.14/180) or abs(turn)>=(190*3.14/180)):
            turning[i].append(turn)
            turn_pts[i].append(contours[i][num])                
            
        
        frag=Fragment()
        frag.turning_angles=turning[i]
        frag.points=contours[i]
        frag.images = []
    #     image_ = Image()
    #     image_.name = "i"+str(i)+".jpeg"
    #     image_.transform_matrix= getIdentitymatrix()
    #     frag.images.append(image_)
    #     print "\nInit Matrix :\n"
    #     print frag.images[0].transform_matrix
        image_ = Image()
        image_.name = tempname
        image_.transform_matrix= getIdentitymatrix()
        frag.images.append(image_)
        print "\nInit Matrix :\n"
        print frag.images[0].transform_matrix
        F.append(frag)
        # print F.ima
        
        
        
        # cv2.drawContours(contour_img[i], contours[i], -1, 255, 1)
        # cv2.imshow('contour_image'+str(i),contour_img[i])
    
    FragmentList=GetMergedImage(F)
    
    print("Hello")
    
    cont3=np.zeros((1000,1000),np.uint8)
    
    # print(get1N2(FragmentList[0].points))
    
    # quit()
    
    for i in range(0,len(FragmentList)):
    #     cv2.drawContours(cont3,get1N2(FragmentList[i].points),-1,255,1)
    #     cv2.imshow("Output" + str(i),cont3)
        final_name = "FINAL"+str(i+1)+".png"
        # FragmentList[i]
        FragmentList[i].points = get1N2(FragmentList[i].points)
        createFinalImage(FragmentList[i],final_name)
        resultList.append(final_name)
    
    
    for name in tempnames:
        try:
            os.remove(name)
        except:
            pass
    #D=GetCandidateMatchSet(F)
    
    
    k=cv2.waitKey(0)
    if(k==27):
        cv2.destroyAllWindows()

    return resultList
dirs = [x for x in os.listdir('.') if os.path.isdir(x)]
dirs.sort()

for d in dirs:
	if args.cont:
		confiles = [d + '/' + x for x in os.listdir(d) if x.endswith(args.ext)]
	else:
		confiles = [d +'/' + [x for x in os.listdir(d) if x.endswith(args.ext)][0] ]# side chain dependent info is not used here
	pid = d.split('_')[0].lower()
	pdb = args.sdir + '/' + pid + '.clean.pdb'

	for confile in confiles:
		conlst = open(confile)
		for con in conlst:
			info = con.strip().split()

			idx, res1, res2, cond = info[0], info[2], info[3], float(info[6])
			if args.cont:
				cond = max(float(info[4]), float(info[5]))
			seeds = []

			if cond > args.cut:
				seeds.extend([res1, res2])
			else:
				continue
			outpdb = General.getBase(confile)[:-1] + '_' + res2.replace(',', '') + '.pdb'
			if os.path.isfile(outpdb):
				continue
			fragmade = Fragment.makeFragments(pdb, seeds, outFile = outpdb, flank = args.flank)
			if fragmade == -1:
				print outpdb, 'not successfully created'