annotate SMART/Java/Python/CompareOverlapping.py @ 53:47310c4fb725

Uploaded

1 #! /usr/bin/env python
2 #
3 # Copyright INRA-URGI 2009-2010
4 # 
5 # This software is governed by the CeCILL license under French law and
6 # abiding by the rules of distribution of free software. You can use,
7 # modify and/ or redistribute the software under the terms of the CeCILL
8 # license as circulated by CEA, CNRS and INRIA at the following URL
9 # "http://www.cecill.info".
10 # 
11 # As a counterpart to the access to the source code and rights to copy,
12 # modify and redistribute granted by the license, users are provided only
13 # with a limited warranty and the software's author, the holder of the
14 # economic rights, and the successive licensors have only limited
15 # liability.
16 # 
17 # In this respect, the user's attention is drawn to the risks associated
18 # with loading, using, modifying and/or developing or reproducing the
19 # software by the user in light of its specific status of free software,
20 # that may mean that it is complicated to manipulate, and that also
21 # therefore means that it is reserved for developers and experienced
22 # professionals having in-depth computer knowledge. Users are therefore
23 # encouraged to load and test the software's suitability as regards their
24 # requirements in conditions enabling the security of their systems and/or
25 # data to be ensured and, more generally, to use and operate it in the
26 # same conditions as regards security.
27 # 
28 # The fact that you are presently reading this means that you have had
29 # knowledge of the CeCILL license and that you accept its terms.
30 #
31 import os, struct, time, random
32 from optparse import OptionParser
33 from commons.core.parsing.ParserChooser import ParserChooser
34 from commons.core.writer.Gff3Writer import Gff3Writer
35 from SMART.Java.Python.structure.Transcript import Transcript
36 from SMART.Java.Python.structure.Interval import Interval
37 from SMART.Java.Python.ncList.NCList import NCList
38 from SMART.Java.Python.ncList.NCListCursor import NCListCursor
39 from SMART.Java.Python.ncList.NCListFilePickle import NCListFilePickle, NCListFileUnpickle
40 from SMART.Java.Python.ncList.NCListHandler import NCListHandler
41 from SMART.Java.Python.ncList.ConvertToNCList import ConvertToNCList
42 from SMART.Java.Python.misc.Progress import Progress
43 from SMART.Java.Python.misc.UnlimitedProgress import UnlimitedProgress
44 from SMART.Java.Python.misc import Utils
45 try:
46 	import cPickle as pickle
47 except:
48 	import pickle
49 
50 REFERENCE = 0
51 QUERY = 1
52 TYPES = (REFERENCE, QUERY)
53 TYPETOSTRING = {0: "reference", 1: "query"}
54 
55 class CompareOverlapping(object):
56 
57 	def __init__(self, verbosity = 1):
58 		self._outputFileName		   = "outputOverlaps.gff3"
59 		self._iWriter				   = None
60 		self._nbOverlappingQueries	   = 0
61 		self._nbOverlaps			   = 0
62 		self._nbLines				   = {REFERENCE: 0, QUERY: 0}
63 		self._verbosity				   = verbosity
64 		self._ncLists				   = {}
65 		self._cursors				   = {}
66 		self._splittedFileNames		   = {}
67 		self._nbElements			   = {}
68 		self._nbElementsPerChromosome  = {}
69 		self._inputFileNames		   = {REFERENCE: None,  QUERY: None}
70 		self._inputFileFormats		   = {REFERENCE: None,  QUERY: None}
71 		self._starts				   = {REFERENCE: None, QUERY: None}
72 		self._ends					   = {REFERENCE: None, QUERY: None}
73 		self._fivePrimes			   = {REFERENCE: None, QUERY: None}
74 		self._threePrimes			   = {REFERENCE: None, QUERY: None}
75 		self._ncListHandlers		   = {REFERENCE: None,  QUERY: None}
76 		self._convertedFileNames	   = {REFERENCE: False, QUERY: False}
77 		self._sorted                   = False
78 		self._index                    = False
79 		self._introns				   = False
80 		self._antisense				   = False
81 		self._colinear				   = False
82 		self._invert				   = False
83 		self._distance				   = 0
84 		self._minOverlap			   = 1
85 		self._pcOverlap				   = None
86 		self._included				   = False
87 		self._including				   = False
88 		self._outputNotOverlapping	   = False
89 		self._tmpRefFileName		   = None
90 		self._currentQueryTranscript   = None
91 		self._currentOrQueryTranscript = None
92 		self._currentExQueryTranscript = None
93 		self._randInt				   = random.randint(0, 100000)
94 		
95 	def __del__(self):
96 		for fileName in [self._tmpRefFileName] + self._convertedFileNames.values():
97 			if fileName != None and os.path.exists(fileName):
98 				os.remove(fileName)
99 
00 	def close(self):
01 		self._iWriter.close()
02 		
03 	def setInput(self, fileName, format, type):
04 		chooser = ParserChooser(self._verbosity)
05 		chooser.findFormat(format)
06 		self._inputFileNames[type]   = fileName
07 		self._inputFileFormats[type] = format
08 		
09 	def setOutput(self, outputFileName):
10 		if outputFileName != '':
11 			self._outputFileName = outputFileName
12 		self._iWriter = Gff3Writer(self._outputFileName)
13 
14 	def setSorted(self, sorted):
15 		self._sorted = sorted
16 
17 	def setIndex(self, index):
18 		self._index = index
19 
20 	def restrictToStart(self, distance, type):
21 		self._starts[type] = distance
22 		
23 	def restrictToEnd(self, distance, type):
24 		self._ends[type] = distance
25 		
26 	def extendFivePrime(self, distance, type):
27 		self._fivePrimes[type] = distance
28 		
29 	def extendThreePrime(self, distance, type):
30 		self._threePrimes[type] = distance
31 
32 	def acceptIntrons(self, boolean):
33 		self._introns = boolean
34 
35 	def getAntisenseOnly(self, boolean):
36 		self._antisense = boolean
37 		
38 	def getColinearOnly(self, boolean):
39 		self._colinear = boolean
40 
41 	def getInvert(self, boolean):
42 		self._invert = boolean
43 
44 	def setMaxDistance(self, distance):
45 		self._distance = distance
46 
47 	def setMinOverlap(self, overlap):
48 		self._minOverlap = overlap
49 
50 	def setPcOverlap(self, overlap):
51 		self._pcOverlap = overlap
52 
53 	def setIncludedOnly(self, boolean):
54 		self._included = boolean
55 		
56 	def setIncludingOnly(self, boolean):
57 		self._including = boolean
58 
59 	def includeNotOverlapping(self, boolean):
60 		self._outputNotOverlapping = boolean
61 		
62 	def transformTranscript(self, transcript, type):
63 		if self._starts[type] != None:
64 			transcript.restrictStart(self._starts[type])
65 		if self._ends[type] != None:
66 			transcript.restrictEnd(self._ends[type])
67 		if self._fivePrimes[type] != None:
68 			transcript.extendStart(self._fivePrimes[type])
69 		if self._threePrimes[type] != None:
70 			transcript.extendEnd(self._threePrimes[type])
71 		if self._introns:
72 			transcript.exons = []
73 		if type == REFERENCE and self._distance > 0:
74 			transcript.extendExons(self._distance)
75 		return transcript
76 
77 	def extendQueryTranscript(self, transcript):
78 		self._currentExQueryTranscript = Transcript()
79 		self._currentExQueryTranscript.copy(transcript)
80 		if self._fivePrimes[QUERY] != None:
81 			self._currentExQueryTranscript.extendStart(self._fivePrimes[QUERY])
82 		if self._threePrimes[QUERY] != None:
83 			self._currentExQueryTranscript.extendEnd(self._threePrimes[QUERY])
84 		transcript.exons = []
85 
86 	def createTmpRefFile(self):
87 		self._tmpRefFileName = "tmp_ref_%d.pkl" % (self._randInt)
88 		if "SMARTTMPPATH" in os.environ:
89 			self._tmpRefFileName = os.path.join(os.environ["SMARTTMPPATH"], self._tmpRefFileName)
90 		chooser = ParserChooser(self._verbosity)
91 		chooser.findFormat(self._inputFileFormats[REFERENCE])
92 		parser = chooser.getParser(self._inputFileNames[REFERENCE])
93 		writer = NCListFilePickle(self._tmpRefFileName, self._verbosity)
94 		for transcript in parser.getIterator():
95 			transcript = self.transformTranscript(transcript, REFERENCE)
96 			writer.addTranscript(transcript)
97 		writer.close()
98 		self._inputFileNames[REFERENCE]   = self._tmpRefFileName
99 		self._inputFileFormats[REFERENCE] = "pkl"
00 
01 	def createNCLists(self):
02 		self._ncLists = dict([type, {}] for type in TYPES)
03 		self._indices = dict([type, {}] for type in TYPES)
04 		self._cursors = dict([type, {}] for type in TYPES)
05 		for type in TYPES:
06 			if self._verbosity > 2:
07 				print "Creating %s NC-list..." % (TYPETOSTRING[type])
08 			self._convertedFileNames[type] = "%s_%d_%d.ncl" % (self._inputFileNames[type], self._randInt, type)
09 			if "SMARTTMPPATH" in os.environ:
10 				self._convertedFileNames[type] = os.path.join(os.environ["SMARTTMPPATH"], self._convertedFileNames[type])
11 			ncLists = ConvertToNCList(self._verbosity)
12 			ncLists.setInputFileName(self._inputFileNames[type], self._inputFileFormats[type])
13 			ncLists.setOutputFileName(self._convertedFileNames[type])
14 			ncLists.setSorted(self._sorted)
15 			if type == REFERENCE and self._index:
16 				ncLists.setIndex(True)
17 			ncLists.run()
18 			self._ncListHandlers[type] = NCListHandler(self._verbosity)
19 			self._ncListHandlers[type].setFileName(self._convertedFileNames[type])
20 			self._ncListHandlers[type].loadData()
21 			self._nbLines[type]					= self._ncListHandlers[type].getNbElements()
22 			self._nbElementsPerChromosome[type] = self._ncListHandlers[type].getNbElementsPerChromosome()
23 			self._ncLists[type]					= self._ncListHandlers[type].getNCLists()
24 			for chromosome, ncList in self._ncLists[type].iteritems():
25 				self._cursors[type][chromosome] = NCListCursor(None, ncList, 0, self._verbosity)
26 				if type == REFERENCE and self._index:
27 					self._indices[REFERENCE][chromosome] = ncList.getIndex()
28 			if self._verbosity > 2:
29 				print "	...done"
30 
31 	def compare(self):
32 		nbSkips, nbMoves   = 0, 0
33 		previousChromosome = None
34 		done			   = False
35 		refNCList		   = None
36 		queryNCList		   = None
37 		startTime		   = time.time()
38 		progress		   = Progress(len(self._ncLists[QUERY].keys()), "Checking overlap", self._verbosity)
39 		for chromosome, queryNCList in self._ncLists[QUERY].iteritems():
40 			queryParser = self._ncListHandlers[QUERY].getParser(chromosome)
41 			queryNCList = self._ncLists[QUERY][chromosome]
42 			queryCursor = self._cursors[QUERY][chromosome]
43 			if chromosome != previousChromosome:
44 				skipChromosome		= False
45 				previousChromosome  = chromosome
46 				if chromosome not in self._ncLists[REFERENCE]:
47 					if self._outputNotOverlapping:
48 						while not queryCursor.isOut():
49 							self._currentQueryTranscript = queryCursor.getTranscript()
50 							self._writeIntervalInNewGFF3({})
51 							if queryCursor.hasChildren():
52 								queryCursor.moveDown()
53 							else:
54 								queryCursor.moveNext()
55 					progress.inc()
56 					continue
57 				refNCList = self._ncLists[REFERENCE][chromosome]
58 				refCursor = self._cursors[REFERENCE][chromosome]
59 			while True:
60 				self._currentOrQueryTranscript = queryCursor.getTranscript()
61 				self._currentQueryTranscript = Transcript()
62 				self._currentQueryTranscript.copy(self._currentOrQueryTranscript)
63 				self._currentQueryTranscript = self.transformTranscript(self._currentQueryTranscript, QUERY)
64 				self.extendQueryTranscript(self._currentOrQueryTranscript)
65 				newRefLaddr = self.checkIndex(refCursor)
66 				if newRefLaddr != None:
67 					nbMoves += 1
68 					refCursor.setLIndex(newRefLaddr)
69 					done = False
70 				refCursor, done, unmatched = self.findOverlapIter(refCursor, done)
71 				if refCursor.isOut():
72 					if not self._invert and not self._outputNotOverlapping:
73 						break
74 				if (unmatched and not self._invert and not self._outputNotOverlapping) or not queryCursor.hasChildren():
75 					queryCursor.moveNext()
76 					nbSkips += 1
77 				else:
78 					queryCursor.moveDown()
79 				if queryCursor.isOut():
80 					break
81 			progress.inc()
82 		progress.done()
83 		endTime = time.time()
84 		self._timeSpent = endTime - startTime
85 		if self._verbosity >= 10:
86 			print "# skips:   %d" % (nbSkips)
87 			print "# moves:   %d" % (nbMoves)
88 
89 	def findOverlapIter(self, cursor, done):
90 		chromosome = self._currentQueryTranscript.getChromosome()
91 		matched	= False
92 		if chromosome not in self._ncLists[REFERENCE]:
93 			return None, False, True
94 		ncList = self._ncLists[REFERENCE][chromosome]
95 		overlappingNames = {}
96 		nextDone = False
97 		firstOverlapLAddr = NCListCursor(cursor)
98 		firstOverlapLAddr.setLIndex(-1)
99 		if cursor.isOut():
00 			self._writeIntervalInNewGFF3(overlappingNames)
01 			return firstOverlapLAddr, False, True
02 		parentCursor = NCListCursor(cursor)
03 		parentCursor.moveUp()
04 		firstParentAfter = False
05 		while not parentCursor.isOut(): 
06 			if self.isOverlapping(parentCursor) == 0:
07 				matched = True
08 				if self._checkOverlap(parentCursor.getTranscript()):
09 					overlappingNames.update(self._extractID(parentCursor.getTranscript()))
10 				if firstOverlapLAddr.isOut():
11 					firstOverlapLAddr.copy(parentCursor)
12 					nextDone = True 
13 			elif self.isOverlapping(parentCursor) == 1:
14 				firstParentAfter = NCListCursor(parentCursor)
15 			parentCursor.moveUp()
16 		if firstParentAfter:
17 			written = self._writeIntervalInNewGFF3(overlappingNames)
18 			return firstParentAfter, False, not written if self._invert else not matched
19 		#This loop finds the overlaps with currentRefLAddr.#
20 		while True:
21 			parentCursor = NCListCursor(cursor)
22 			parentCursor.moveUp()
23 			#In case: Query is on the right of the RefInterval and does not overlap.
24 			overlap = self.isOverlapping(cursor)
25 			if overlap == -1:
26 				cursor.moveNext()
27 			#In case: Query overlaps with RefInterval.	
28 			elif overlap == 0:
29 				matched = True
30 				if self._checkOverlap(cursor.getTranscript()):
31 					overlappingNames.update(self._extractID(cursor.getTranscript()))
32 				if firstOverlapLAddr.compare(parentCursor):
33 					firstOverlapLAddr.copy(cursor)
34 					nextDone = True
35 				if done:
36 					cursor.moveNext()
37 				else:
38 					if not cursor.hasChildren():
39 						cursor.moveNext()
40 						if cursor.isOut():
41 							break
42 					else:
43 						cursor.moveDown()
44 			#In case: Query is on the left of the RefInterval and does not overlap.		
45 			else:
46 				if firstOverlapLAddr.isOut() or firstOverlapLAddr.compare(parentCursor):
47 					firstOverlapLAddr.copy(cursor)
48 					nextDone = False # new
49 				break
50 			
51 			done = False
52 			if cursor.isOut():
53 				break
54 		written = self._writeIntervalInNewGFF3(overlappingNames)
55 		return firstOverlapLAddr, nextDone, not written if self._invert else not matched
56 	
57 	def isOverlapping(self, refTranscript):
58 		if (self._currentExQueryTranscript.getStart() <= refTranscript.getEnd() and self._currentExQueryTranscript.getEnd() >= refTranscript.getStart()):
59 			return 0   
60 		if self._currentExQueryTranscript.getEnd() < refTranscript.getStart():
61 			return 1
62 		return -1
63 
64 	def checkIndex(self, cursor):
65 		if not self._index:
66 			return None
67 		if cursor.isOut():
68 			return None
69 		chromosome = self._currentExQueryTranscript.getChromosome()
70 		nextLIndex = self._indices[REFERENCE][chromosome].getIndex(self._currentExQueryTranscript)
71 		if nextLIndex == None:
72 			return None
73 		ncList		 = self._ncLists[REFERENCE][chromosome]
74 		nextGffAddress = ncList.getRefGffAddr(nextLIndex)
75 		thisGffAddress = cursor.getGffAddress()
76 		if nextGffAddress > thisGffAddress:
77 			return nextLIndex
78 		return None
79 		
80 	def _writeIntervalInNewGFF3(self, names):
81 		nbOverlaps = 0
82 		for cpt in names.values():
83 			nbOverlaps += cpt
84 		self._nbOverlappingQueries += 1		      if Utils.xor(names, self._invert) else 0
85 		self._nbOverlaps		   += nbOverlaps  if Utils.xor(names, self._invert) else 0
86 		if names:
87 			self._currentQueryTranscript.setTagValue("overlapWith", ",".join(names))
88 			self._currentQueryTranscript.setTagValue("nbOverlaps", nbOverlaps)
89 			if self._invert:
90 				return False
91 		else:
92 			if self._outputNotOverlapping:
93 				self._currentQueryTranscript.setTagValue("nbOverlaps", 0)
94 			elif not self._invert:
95 				return False
96 		self._iWriter.addTranscript(self._currentQueryTranscript)
97 		self._iWriter.write()
98 		return True
99 		
00 	def _extractID(self, transcript):
01 		id		 = transcript.getTagValue("ID")		      if "ID"		  in transcript.getTagNames() else transcript.getUniqueName()
02 		nbElements = transcript.getTagValue("nbElements") if "nbElements" in transcript.getTagNames() else 1
03 		return {id: float(nbElements)}
04 
05 	def _checkOverlap(self, refTranscript):
06 		if self._currentQueryTranscript.getDistance(refTranscript) > self._distance:
07 			return False
08 		minOverlap = self._minOverlap
09 		if self._pcOverlap != None:
10 			minOverlap = max(self._minOverlap, self._currentQueryTranscript.getSize() / 100.0 * self._pcOverlap)
11 		if not self._currentQueryTranscript.overlapWith(refTranscript, minOverlap):
12 			return False
13 		if self._antisense and self._currentQueryTranscript.getDirection() == refTranscript.getDirection():
14 			return False
15 		if self._colinear and self._currentQueryTranscript.getDirection() != refTranscript.getDirection():
16 			return False
17 		if self._included and not refTranscript.include(self._currentQueryTranscript):
18 			return False
19 		if self._including and not self._currentQueryTranscript.include(refTranscript):
20 			return False
21 		if self._introns:
22 			return True
23 		return self._currentQueryTranscript.overlapWithExon(refTranscript, minOverlap)
24 		
25 	def run(self):
26 		self.createTmpRefFile()
27 		self.createNCLists()
28 		self.compare()
29 		self.close()
30 		if self._verbosity > 0:
31 			print "# queries: %d" % (self._nbLines[QUERY])
32 			print "# refs:	  %d" % (self._nbLines[REFERENCE])
33 			print "# written: %d (%d overlaps)" % (self._nbOverlappingQueries, self._nbOverlaps)
34 			print "time: 	  %ds" % (self._timeSpent)
35 
36 
37 if __name__ == "__main__":
38 	description = "Compare Overlapping v1.0.4: Get the data which overlap with a reference set. [Category: Data Comparison]"
39 
40 	parser = OptionParser(description = description)
41 	parser.add_option("-i", "--input1",		      dest="inputFileName1", action="store",					 type="string", help="input file 1 [compulsory] [format: file in transcript format given by -f]")
42 	parser.add_option("-f", "--format1",		  dest="format1",		 action="store",					 type="string", help="format of file 1 [compulsory] [format: transcript file format]")
43 	parser.add_option("-j", "--input2",		      dest="inputFileName2", action="store",					 type="string", help="input file 2 [compulsory] [format: file in transcript format given by -g]")
44 	parser.add_option("-g", "--format2",		  dest="format2",		 action="store",					 type="string", help="format of file 2 [compulsory] [format: transcript file format]")
45 	parser.add_option("-o", "--output",		      dest="output",		 action="store",	  default=None,  type="string", help="output file [compulsory] [format: output file in GFF3 format]")
46 	parser.add_option("-D", "--index",	          dest="index",	         action="store_true", default=False,	            help="add an index to the reference file (faster but more memory) [format: boolean] [default: False]")
47 	parser.add_option("-r", "--sorted",	          dest="sorted",	     action="store_true", default=False,	            help="input files are already sorted [format: boolean] [default: False]")
48 	parser.add_option("-S", "--start1",		      dest="start1",		 action="store",	  default=None,  type="int",	help="only consider the n first nucleotides of the transcripts in file 1 (do not use it with -U) [format: int]")
49 	parser.add_option("-s", "--start2",		      dest="start2",		 action="store",	  default=None,  type="int",	help="only consider the n first nucleotides of the transcripts in file 2 (do not use it with -u) [format: int]")
50 	parser.add_option("-U", "--end1",			  dest="end1",		     action="store",	  default=None,  type="int",	help="only consider the n last nucleotides of the transcripts in file 1 (do not use it with -S) [format: int]")
51 	parser.add_option("-u", "--end2",			  dest="end2",		     action="store",	  default=None,  type="int",	help="only consider the n last nucleotides of the transcripts in file 2 (do not use it with -s) [format: int]")
52 	parser.add_option("-t", "--intron",		      dest="introns",		 action="store_true", default=False,				help="also report introns [format: bool] [default: false]")
53 	parser.add_option("-E", "--5primeExtension1", dest="fivePrime1",	 action="store",	  default=None,  type="int",	help="extension towards 5' in file 1 [format: int]")
54 	parser.add_option("-e", "--5primeExtension2", dest="fivePrime2",	 action="store",	  default=None,  type="int",	help="extension towards 5' in file 2 [format: int]")
55 	parser.add_option("-N", "--3primeExtension1", dest="threePrime1",	 action="store",	  default=None,  type="int",	help="extension towards 3' in file 1 [format: int]")
56 	parser.add_option("-n", "--3primeExtension2", dest="threePrime2",	 action="store",	  default=None,  type="int",	help="extension towards 3' in file 2 [format: int]")
57 	parser.add_option("-c", "--colinear",		  dest="colinear",		 action="store_true", default=False,				help="colinear only [format: bool] [default: false]")
58 	parser.add_option("-a", "--antisense",		  dest="antisense",		 action="store_true", default=False,				help="antisense only [format: bool] [default: false]")
59 	parser.add_option("-d", "--distance",		  dest="distance",	     action="store",	  default=0,	 type="int",	help="accept some distance between query and reference [format: int]")
60 	parser.add_option("-k", "--included",		  dest="included",	     action="store_true", default=False,				help="keep only elements from file 1 which are included in an element of file 2 [format: bool] [default: false]")
61 	parser.add_option("-K", "--including",		  dest="including",	     action="store_true", default=False,				help="keep only elements from file 2 which are included in an element of file 1 [format: bool] [default: false]")
62 	parser.add_option("-m", "--minOverlap",		  dest="minOverlap",	 action="store",	  default=1,	 type="int",	help="minimum number of nucleotides overlapping to declare an overlap [format: int] [default: 1]")
63 	parser.add_option("-p", "--pcOverlap",		  dest="pcOverlap",	     action="store",	  default=None,  type="int",	help="minimum percentage of nucleotides to overlap to declare an overlap [format: int]")
64 	parser.add_option("-O", "--notOverlapping",   dest="notOverlapping", action="store_true", default=False,				help="also output not overlapping data [format: bool] [default: false]")
65 	parser.add_option("-x", "--exclude",		  dest="exclude",		 action="store_true", default=False,				help="invert the match [format: bool] [default: false]")
66 	parser.add_option("-v", "--verbosity",		  dest="verbosity",		 action="store",	  default=1,	 type="int",	help="trace level [format: int]")
67 	(options, args) = parser.parse_args()
68 
69 	co = CompareOverlapping(options.verbosity)
70 	co.setInput(options.inputFileName1, options.format1, QUERY)
71 	co.setInput(options.inputFileName2, options.format2, REFERENCE)
72 	co.setOutput(options.output)
73 	co.setSorted(options.sorted)
74 	co.setIndex(options.index)
75 	co.restrictToStart(options.start1, QUERY)
76 	co.restrictToStart(options.start2, REFERENCE)
77 	co.restrictToEnd(options.end1, QUERY)
78 	co.restrictToEnd(options.end2, REFERENCE)
79 	co.extendFivePrime(options.fivePrime1, QUERY)
80 	co.extendFivePrime(options.fivePrime2, REFERENCE)
81 	co.extendThreePrime(options.threePrime1, QUERY)
82 	co.extendThreePrime(options.threePrime2, REFERENCE)
83 	co.acceptIntrons(options.introns)
84 	co.getAntisenseOnly(options.antisense)
85 	co.getColinearOnly(options.colinear)
86 	co.getInvert(options.exclude)
87 	co.setMaxDistance(options.distance)
88 	co.setMinOverlap(options.minOverlap)
89 	co.setPcOverlap(options.pcOverlap)
90 	co.setIncludedOnly(options.included)
91 	co.setIncludingOnly(options.including)
92 	co.includeNotOverlapping(options.notOverlapping)
93 	co.run()