Example #1
0
	def __add(self, event): 
		if ( not self.__init) : 
			IJ.showMessage("", "please start a new stack")
			return
		if ( not self.__initDIA) :
			IJ.showMessage("", "please select an image for DIA")
			return

		if ( not self.__initFLUO) :
			IJ.showMessage("", "please select an image for FLUO")
			return
		
		self.__widthl = self.__display2.getText()
		roi = self.__impD.getRoi()
		
		if roi == None : 
			IJ.showMessage("", "No selection")
			return

		if roi.getType() in [6,7] : 		
			nslice = self.__impD.getCurrentSlice()
			self.__impF.setSlice(nslice)
			self.__impF.setRoi(roi)
		elif roi.getType() in [2,4] :
			nslice = self.__impD.getCurrentSlice()
			self.__impF.setSlice(nslice)
			m=Morph(self.__impF, roi)
			m.setMidParams(10, 2)
			roi=m.MidAxis
			if roi == None :
				self.__display.text = "roi fail"
				if not self.__skip : IJ.showMessage("", "failed roi, please draw it as polyline")
				return				

		#if roi.getType() != 6 : self.__impF.setRoi(roi)
		else : 
			IJ.showMessage("", "This selection is not yet allowed")
			return

		self.__impF.setRoi(roi)
		
		straightener = Straightener()
		new_ip = straightener.straighten(self.__impF, roi, int(self.__widthl))
		
		self.__iplist.append(new_ip)
		self.__labels.append(self.__isF.getShortSliceLabel(nslice))
		
		self.__display.text = self.__name + " cell " + str(len(self.__iplist)) +" width="+str(new_ip.getWidth())+ " height="+ str(new_ip.getHeight())
		roi.setPosition(self.__impD.getCurrentSlice())	

		self.__rm = RoiManager.getInstance()
		if (self.__rm==None): self.__rm = RoiManager()
		
		self.__rm.add(self.__impD, roi, len(self.__iplist))
		self.__cellsrois.append((roi, self.__impD.getCurrentSlice()))
		#self.__rm.runCommand("Show All")

		IJ.selectWindow(self.__impD.getTitle()) 
Example #2
0
	def getIncludeRois(self):
		self.__yieldRois=[]
		self.__yieldRois[:]=[]
		for roi in self.__roisArray:
			m=Morph(self.__image, roi)
			state=0
			for r in self.__ranges.values():
				if r[1]<=m.__getattribute__(r[0])<=r[2]: state=state+0 
				else: state=state+1
			if state<1 : self.__yieldRois.append(roi)
		return self.__yieldRois
Example #3
0
	def __measureAll(self,img,measure,changeslice, name, noise) :
		"""
		Measures a characteristic for all the cells in a stack.

		"""
		dico=self.__dictCells[name]
		
		if changeslice == True : img.setSlice(1)
		for cellname in dico.keys() :
			roitemp=dico[cellname].getRoi(0)
			self.__dictMeasures[dico[cellname]][measure]=[]
			if isinstance(roitemp,Roi) :
				m=Morph(img,roitemp)				
				if noise is not None : m.setNoise(noise)
				self.__dictMeasures[dico[cellname]][measure].append(m.__getattribute__(measure))
				#self.__dictMeasures[dico[cellname]][measure].append(Morph(img,roitemp).__getattribute__(measure))
			else :
				self.__dictMeasures[dico[cellname]][measure].append(Double.NaN)
		
		for i in range(2,img.getImageStackSize()+1) :
			if changeslice == True : img.setSlice(i)
			for cellname in dico.keys() :
				roitemp=dico[cellname].getRoi(i-1)
				if isinstance(roitemp,Roi) :
					m=Morph(img,roitemp)				
					if noise is not None : m.setNoise(noise)
					self.__dictMeasures[dico[cellname]][measure].append(m.__getattribute__(measure))
					#self.__dictMeasures[dico[cellname]][measure].append(Morph(img,roitemp).__getattribute__(measure))
				else :
					self.__dictMeasures[dico[cellname]][measure].append(Double.NaN)
Example #4
0
		def buttonPressed(event):
			temprois=self.getIncludeRois()
			for roi in temprois:
				m=Morph(self.__image, roi)
				IJ.log("----------------------------------")
				IJ.log(roi.getName())
				for r in self.__ranges.values():
					IJ.log(r[0]+" min= "+str(r[1])+" < val="+str(m.__getattribute__(r[0]))+" < max= "+str(r[2]))
			IJ.run(self.__image, "Remove Overlay", "")
			o=Overlay()
			for roi in temprois:
				o.addElement(roi)
			self.__image.killRoi()
			self.__image.setOverlay(o)
			self.__image.updateAndDraw()
Example #5
0
	def __measureVelocity(self, img, name) :
		measure = "velocity"
		dico=self.__dictCells[name]
		for cellname in dico.keys() :
			roitemp=dico[cellname].getRoi(0)
			xc = self.__dictMeasures[dico[cellname]]["XC"]
			yc = self.__dictMeasures[dico[cellname]]["YC"]
			d=[]
			for i in range(len(xc)-1) :
				tempseq = [ xc[i], xc[i+1], yc[i], yc[i+1] ]
				if not any(Double.isNaN(val)==True for val in tempseq ) :
					d.append(Morph.distMorph([[1, xc[i], xc[i+1]],[1, yc[i], yc[i+1]]]))
				else : d.append(Double.NaN)
			d.append(Double.NaN)
			self.__dictMeasures[dico[cellname]][measure]=d
			del(d)					
Example #6
0
	def __measurecumulDist(self, img, name) :
		measure = "cumulatedDist"
		dico=self.__dictCells[name]
		for cellname in dico.keys() :
			roitemp=dico[cellname].getRoi(0)
			xc = self.__dictMeasures[dico[cellname]]["XC"]
			yc = self.__dictMeasures[dico[cellname]]["YC"]
			d=[]
			d.append(0)
			for i in range(1,len(xc)-1) :
				tempseq = [ xc[i], xc[i+1], yc[i], yc[i+1] ]
				if not any(Double.isNaN(val)==True for val in tempseq ) :
					lastdist = Morph.distMorph([[1, xc[i], xc[i+1]],[1, yc[i], yc[i+1]]])
					d.append(d[-1]+lastdist)
				else : d.append(Double.NaN)
			d.append(Double.NaN)
			self.__dictMeasures[dico[cellname]][measure]=d
			del(d)		
Example #7
0
		ci = len(xpoints)//2
		centres[i]=(xpoints[ci], ypoints[ci])
		pos.append(centres[i])

		# chgt repere pour centroide
		x0=pointsA[i-1][0]-centres[i-1][0]
		y0=pointsA[i-1][1]-centres[i-1][1]


		x1=xpoints[0]-centres[i][0]
		y1=ypoints[0]-centres[i][1]
	
		x2=xpoints[-1]-centres[i][0]
		y2=ypoints[-1]-centres[i][1]

		d1=Morph.distMorph([(1,x0,x1),(1, y0, y1)]) # dist from old A to new extem1
		d2=Morph.distMorph([(1,x0,x2),(1, y0, y2)])# dist from old A to new extem2
		
		if d1<=d2 :
			pointsA[i]=(xpoints[0], ypoints[0]) # new A is the closest from old A
			pointsB[i]=(xpoints[-1], ypoints[-1])
			pointsC[i]=(xpoints[1], ypoints[1])
			pointsD[i]=(xpoints[-2], ypoints[-2])
		else : 
			pointsB[i]=(xpoints[0], ypoints[0])
			pointsA[i]=(xpoints[-1], ypoints[-1]) # new A is the closest from old A
			pointsC[i]=(xpoints[-2], ypoints[-2])
			pointsD[i]=(xpoints[1], ypoints[1])

		# ------- coordonees image ------------
		xa0=pointsA[i-1][0]
Example #8
0
	def __addroi(self, event) :
		if ( not self.__init) : 
			IJ.showMessage("", "please start a new stack")
			return
		if ( not self.__initDIA) :
			IJ.showMessage("", "please select an image for DIA")
			return

		if ( not self.__initFLUO) :
			IJ.showMessage("", "please select an image for FLUO")
			return

		twres = TextWindow("measures-"+self.__name, "label\tname\tsol\tarea\tcirc\tAR\tFeret\taxis\traf\tdMajor\tdFeret\tdArea", "", 300, 450)
		tab="\t"
		
		self.__widthl = self.__display2.getText()
		IJ.selectWindow(self.__impF.getTitle())

		self.__rm = RoiManager.getInstance()
		if (self.__rm==None): self.__rm = RoiManager()

		if self.__impF.getImageStackSize() > 1 :
			roisarray =[(roi, self.__rm.getSliceNumber(roi.getName())) for roi in self.__rm.getRoisAsArray()]
		else : 
			roisarray =[(roi, 1) for roi in self.__rm.getRoisAsArray()]
			
		self.__rm.runCommand("reset")
		#self.__rm.runCommand("Delete")
		IJ.selectWindow(self.__impF.getTitle())

		self.__maxraf=float(self.__display19.text)
		self.__minraf=float(self.__display20.text)

		count=1

		for roielement in roisarray :
			roi = roielement[0]
			pos = roielement[1]
			lab = self.__impF.getImageStack().getShortSliceLabel(pos)

			if lab==None : lab=str(pos)
			
			if self.__conEllipses :
				IJ.selectWindow(self.__impF.getTitle())
				self.__impF.setSlice(pos)
				self.__impF.setRoi(roi)
				self.__rm.runCommand("Add")
				IJ.run(self.__impF,  "Fit Ellipse", "")
				ellipse=self.__impF.getRoi()
				params = ellipse.getParams()
				ferets = ellipse.getFeretValues()
				imp2 = Duplicator().run(self.__impF,pos,pos)
				IJ.run(imp2, "Rotate... ", "angle="+str(ferets[1])+" grid=0 interpolation=Bilinear enlarge slice")
				temproi=Roi((imp2.getWidth()-ferets[0])/2.0,(imp2.getHeight()-ferets[2])/2.0,ferets[0],ferets[2])
				imp2.setRoi(temproi)
				imp3 = Duplicator().run(imp2,1,1)
				ip3=imp3.getProcessor()

				if int(self.__display5.text) < ip3.getWidth() < int(self.__display6.text) : 
					self.__iplist.append(ip3)
					self.__display.text = self.__name + " cell " + str(len(self.__iplist))
					fer=Line(params[0],params[1],params[2],params[3])
					self.__cellsrois.append((fer, pos))
					self.__labels.append(self.__isF.getShortSliceLabel(pos))

				m=Morph(self.__impF, roi)

				twres.append(lab+tab+str(roi.getName())+tab+str(m.Solidity)+tab+str(m.Area)+tab+str(m.Circ)+tab+str(m.AR)+tab+str(m.MaxFeret)+tab+str(fer.getLength())+tab+str(1)+tab+str(0)+tab+str(0)+tab+str(0))
				self.__dictCells[count]=(str(roi.getName()), lab, roi)
				count=count+1
				continue
			
			if roi.getType() in [6,7] : 
				self.__impF.setSlice(pos)
				self.__impF.setRoi(roi)
				self.__rm.runCommand("Add")

			elif roi.getType() in [2,4] :
				self.__impF.setSlice(pos)
				self.__impF.setRoi(roi)
				m=Morph(self.__impF, roi)
				m.setMidParams(10, 2)
				midroi=m.MidAxis
				if midroi == None : continue

				raf = m.MaxFeret/midroi.getLength()
				
				if (self.__maxraf < raf) or (raf < self.__minraf) : continue

				maxsol = float(self.__display7.text)
				minsol = float(self.__display8.text)
				maxarea = float(self.__display9.text)
				minarea = float(self.__display10.text)
				maxcirc = float(self.__display11.text)
				mincirc = float(self.__display12.text)
				maxar = float(self.__display13.text)
				minar = float(self.__display14.text)
				maxfer = float(self.__display15.text)
				minfer = float(self.__display16.text)
				maxmean = float(self.__display17.text)
				minmean = float(self.__display18.text)
				maxmferet = float(self.__display21.text)
				minmferet = float(self.__display22.text)

				testsol = (minsol< m.Solidity < maxsol)
				testarea = (minarea< m.Area < maxarea)
				testcirc = (mincirc< m.Circ < maxcirc)
				testar = (minar< m.AR < maxar)
				testfer = (minfer< m.MaxFeret < maxfer)
				testmean = (minmean < m.Mean < maxmean)
				testmferet = (minmferet < m.MinFeret < maxmferet)
				
				#print minmferet , m.MinFeret , maxmferet

				test = (testsol+testarea+testcirc+testar+testfer+testmean+testmferet)/7	

				if test : 				
					
					fmaj, ffmx, fa =[],[],[]
					for r in m.getMidSegments(10, 40, 0) :
						if r == None : continue
						m2=Morph(self.__impF, r)
						fmaj.append(m2.Major)
						ffmx.append(m2.MaxFeret)
						fa.append(m2.Area)

					diffmajor, diffferet, diffarea = 0,0,0
					
					if len(fa) > 4 :
						medfmaj = self.listmean(fmaj[1:-1])
						medffmx = self.listmean(ffmx[1:-1])
						medfa   = self.listmean(fa[1:-1])

						diffmajor = (max(fmaj[1:-1])-medfmaj)/medfmaj
						diffferet = (max(ffmx[1:-1])-medffmx)/medffmx
						diffarea = (max(fa[1:-1])-medfa)/medfa

					twres.append(lab+tab+str(roi.getName())+tab+str(m.Solidity)+tab+str(m.Area)+tab+str(m.Circ)+tab+str(m.AR)+tab+str(m.MaxFeret)+tab+str(midroi.getLength())+tab+str(m.MaxFeret/midroi.getLength())+tab+str(diffmajor)+tab+str(diffferet)+tab+str(diffarea))
					#print lab+tab+str(roi.getName())+tab+str(m.Solidity)+tab+str(m.Area)+tab+str(m.Circ)+tab+str(m.AR)+tab+str(m.MaxFeret)+tab+str(midroi.getLength())+tab+str(m.MaxFeret/midroi.getLength())+tab+str(diffmajor)+tab+str(diffferet)+tab+str(diffarea)

					self.__impF.setRoi(roi)
					self.__rm.runCommand("Add")
					self.__impF.killRoi()
					self.__impF.setRoi(midroi)
					
					#self.__dictCells[str(roi.getName())]=(str(roi.getName()), lab, roi)
					self.__dictCells[count]=(str(roi.getName()), lab, roi)
					count=count+1
					
				else : 
					#print "test falls"
					continue

			else : 
				print "out loop"
				continue
			
			straightener = Straightener()
			new_ip = straightener.straighten(self.__impF, midroi, int(self.__widthl))
			
			if int(self.__display5.text) < new_ip.getWidth() < int(self.__display6.text) : 
				self.__iplist.append(new_ip)
				self.__display.text = self.__name + " cell " + str(len(self.__iplist))
				#print "add", roi.getName(), roi.getType()
				self.__cellsrois.append((midroi, pos))
				self.__labels.append(self.__isF.getShortSliceLabel(pos))


		#roisarray=self.__rm.getRoisAsArray()		
		#self.__rm.runCommand("reset")
		#self.__rm.runCommand("Delete")
		

		self.__impD.killRoi()
		self.__impF.killRoi()
		IJ.selectWindow(self.__impD.getTitle()) 
Example #9
0
def link(img, sliceA, sliceB, RoisA, RoisB, coeffs, distmethod, optionangle, nbdigits, boolnews) :
	"""
	 This function takes in entry an image, two slices, two arrays of ROIs, a list of coefficients, and a string corresponding to the name of a method.
	 It aims at linking the different ROIs of an image to the ROIs of another image, according to the method and to the coefficients given in entry.
	 It returns 3 lists of tuples :		- one in which the tuples correspond to two ROIs linked.
	 					- another one in which the tuples correspond to new bacteria
	 					- a last one in which the tuples correspond to "lost" bacteria.
	"""	


	rawcoeffs=[coeffs[i] for i in range(0,len(coeffs), 2)]
	#maxdists=[0.01*coeffs[i] for i in range(1,len(coeffs), 2)]
	maxdists=[coeffs[i] for i in range(1,len(coeffs), 2)]

	
	# Definition of the different parameters used in the distance.
	
	measure=[]
	measure.append("Area")
	measure.append("Angle")
	measure.append("MaxFeret")
	measure.append("XC")
	measure.append("YC")


	#Delata max normalization:
	coeffdist=[rawcoeffs[i]/(maxdists[i]*sum(rawcoeffs)) for i in range(5)]

	# Calcul of the constant in order to flag the cells that are out of range (according to the preferences of the user)
	#maxdisteuclarray=[]
	#maxdisteuclarray.append(math.sqrt(coeffdist[0]/sum(coeffdist)*(maxdists[0]*img.getWidth()*img.getHeight())**2))
	#maxdisteuclarray.append(math.sqrt(coeffdist[1]/sum(coeffdist)*(maxdists[1]*180)**2))
	#maxdisteuclarray.append(math.sqrt(coeffdist[2]/sum(coeffdist)*(maxdists[2]*math.sqrt((img.getWidth())**2+(img.getHeight())**2))**2))
	#maxdisteuclarray.append(math.sqrt(coeffdist[3]/sum(coeffdist)*(maxdists[3]*img.getWidth())**2))
	#maxdisteuclarray.append(math.sqrt(coeffdist[4]/sum(coeffdist)*(maxdists[4]*img.getHeight())**2))
	#maxdisteucl=max(maxdisteuclarray)

	maxdisteuclarray=[math.sqrt(coeffdist[i]*(maxdists[i]**2)) for i in range(5)]
	#MAXDIST=max(maxdisteuclarray)

	MAXDIST=math.sqrt(max(maxdists)**2)
	
	#if distmethod=="Logarithm distance" :
	#	for i in range(len(maxdists)) :
	#		if maxdists[i]==1 :
	#			maxdists[i]-=10**(-nbdigits)
	#	MAXDIST=max([abs(math.log(1-maxdists[i])) for i in range(5)])

	#if distmethod=="Euclidean distance" :
	#	maxdisteuclarray=[]
	#	maxdisteuclarray.append(math.sqrt(coeffdist[0]/sum(coeffdist)*(maxdists[0]*img.getWidth()*img.getHeight())**2))
	#	maxdisteuclarray.append(math.sqrt(coeffdist[1]/sum(coeffdist)*(maxdists[1]*180)**2))
	#	maxdisteuclarray.append(math.sqrt(coeffdist[2]/sum(coeffdist)*(maxdists[2]*math.sqrt((img.getWidth())**2+(img.getHeight())**2))**2))
	#	maxdisteuclarray.append(math.sqrt(coeffdist[3]/sum(coeffdist)*(maxdists[3]*img.getWidth())**2))
	#	maxdisteuclarray.append(math.sqrt(coeffdist[4]/sum(coeffdist)*(maxdists[4]*img.getHeight())**2))
	#	MAXDIST=max(maxdisteuclarray)
		
	#img.hide()


	# Creation of the "matrix" of the different distances between all couples of RoisA and RoisB possible.
	# The "matrix" is a dictionnary with tuples of ROIs (ROISA,ROISB) as key, and tuples (distance,(ROIA,ROIB)) as values
	
	listedist={}
	for roisA in RoisA :
		morphA=Morph(img, roisA)
		for roisB in RoisB :
			morphB=Morph(img, roisB)
			#if distmethod=="Logarithm distance" :
			#	val=[ [ coeffdist[i]/sum(coeffdist), morphA.__getattribute__(measure[i]), morphB.__getattribute__(measure[i]) ]  for i in range(3) ] 
			#	val.append([coeffdist[3]/sum(coeffdist),img.getWidth() ,max(morphA.__getattribute__(measure[3]),morphB.__getattribute__(measure[3]))-min(morphA.__getattribute__(measure[3]),morphB.__getattribute__(measure[3]))])
			#	val.append([coeffdist[4]/sum(coeffdist),img.getHeight() ,max(morphA.__getattribute__(measure[4]),morphB.__getattribute__(measure[4]))-min(morphA.__getattribute__(measure[4]),morphB.__getattribute__(measure[4]))])
			#else	:	val=[ [ coeffdist[i]/sum(coeffdist), morphA.__getattribute__(measure[i]), morphB.__getattribute__(measure[i]) ]  for i in range(5) ] 
			rawval=[ [ 1, morphA.__getattribute__(measure[i]), morphB.__getattribute__(measure[i]) ]  for i in range(5) ] 
			val=[ [ coeffdist[i], morphA.__getattribute__(measure[i]), morphB.__getattribute__(measure[i]) ]  for i in range(5) ] 
			#print rawval
			#print "----"
			#for v in val : print math.sqrt(v[0]*(v[2]-v[1])*(v[2]-v[1]))
			
			# We make sure there is no null value
			out=""
			
			for i in range(5): 
				if val[i][1]==0 :
					val[i][1]+=10**(-nbdigits)
				if val[i][2]==0 :
					val[i][2]+=10**(-nbdigits)
					
			#	if abs(rawval[i][2]-rawval[i][1])>maxdists[i]: out = "out of range"

			#print "area", rawval[0][2], "/", rawval[0][1],">", maxdists[0],"=", abs(rawval[0][2]/rawval[0][1])>maxdists[0]
			#print "feret", rawval[2][2], "/", rawval[2][1],">", maxdists[2],"=", abs(rawval[2][2]/rawval[2][1])>maxdists[2]

			if abs(rawval[1][2]-rawval[1][1])>maxdists[1]: out = "out of range"
			if abs(rawval[3][2]-rawval[3][1])>maxdists[3]: out = "out of range"
			if abs(rawval[4][2]-rawval[4][1])>maxdists[4]: out = "out of range"

			if abs(rawval[0][2]/rawval[0][1])>maxdists[0]: 
				out = "out of range"
			if abs(rawval[2][2]/rawval[2][1])>maxdists[2]: 
				out = "out of range"
				
			if optionangle==True :
				if val[1][1]>=178 : val[1][1]=180-val[1][1]
				if val[1][2]>=178 : val[1][2]=180-val[1][2]
			
			# We check if the value is in the interval defined by the user.
			#out=""
			#for i in range(3):
			#	if 1-(min(val[i][1], val[i][2])/max(val[i][1], val[i][2]))  > maxdists[i] : 
			#		out="out of range"
			#		print "out of range i=",i,"car : delta=",1-(min(val[i][1], val[i][2])/max(val[i][1], val[i][2]))," et maxdists[i] :",maxdists[i]
			#if distmethod=="Euclidean distance" :
			#	deltax=(max(val[3][1],val[3][2])-min(val[3][1],val[3][2]))/img.getWidth()
			#	deltay=(max(val[4][1],val[4][2])-min(val[4][1],val[4][2]))/img.getHeight()
			#	if deltax > maxdists[3] or deltay > maxdists[4] : 
			#		out="out of range"
			#		print "out of range 3-4 car : delta=",deltax,"  ",deltay," et maxdists3-4 :",maxdists[3]," ",maxdists[4]
			#if distmethod=="Logarithm distance" :
			#	if val[3][2]/val[3][1] > maxdists[3] or val[4][2]/val[4][1] > maxdists[4] : 
			#		out = "out of range"
			#		print "out of range 3-4 car : rapport=",val[3][2]/val[3][1],"  ",val[4][2]/val[4][1]," et maxdists3-4 :",maxdists[3]," ",maxdists[4]
			if out == "" :
				listedist[(roisA,roisB)]=(Morph.distMorph(val,distmethod),(roisA,roisB))
				
			else : listedist[(roisA,roisB)]=(MAXDIST,(roisA,roisB))
			
			
	# The mininum of all distances is found in the matrix, and if it is < to a certain value, then the couple of ROIs linked is added in a list "liens".
	# Then all couples having one of the two ROIs considered just before are deleted from the "matrix".
	# And while the length of "liens" is not equal to the minimum of the length of RoisA and RoisB, or the mininum is inferior to the value "seuil", we repeat the algorithm.
	# The list of tuples "liens" is returned by the function.
	#print listedist
	liens = []
	for i in range(min([len(RoisA),len(RoisB)])) :
		mindist=min(listedist.values())
		#print "(",mindist,";",i,";",min([len(RoisA),len(RoisB)]),")"
		if mindist[0]>=MAXDIST : 
			break
		else :
			minroisA=mindist[1][0]
			minroisB=mindist[1][1]
			liens.append((minroisA,minroisB))
			for cle in listedist.keys() :
				if cle[0]==minroisA or cle[1]==minroisB :
					del listedist[cle]

	# If any ROI of RoisA doesn't appear in the list of tuples "liens", then the ROI is considered to be "LOST"; and the list of tuples of ROIs lost is returned by the function.
	
	lost=[]
	for roisA in RoisA:
		marqueurtemp = False
		for lien in liens :
			if lien[0] == roisA :
				marqueurtemp = True
				break
		if marqueurtemp == False :
			lost.append(("LOST",roisA))


	# If any ROI of RoisB doesn't appear in the list of tuples "liens", then the ROI is considered to be "NEW"; and the list of tuples of new ROIs is returned by the function.
	
	new=[]
	if boolnews :
		for roisB in RoisB	:
			marqueurtemp = False
			for lien in liens :
				if lien[1] == roisB :
					marqueurtemp = True
					break
			if marqueurtemp == False :
				new.append(("NEW",roisB))


	# The function "link" returns a tuples of all three lists of tuples : "liens", "new", and "lost"
	
	return (liens,new,lost)