ACE/EdgeFactory.C at master · bmajoros/ACE · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
/****************************************************************
 EdgeFactory.C
 Copyright (C)2013 William H. Majoros (martiandna@gmail.com).
 This is OPEN SOURCE SOFTWARE governed by the Gnu General Public
 License (GPL) version 3, as described at www.opensource.org.
 ****************************************************************/
#include "EdgeFactory.H"
#include <iostream>
#include "Signal.H"
#include "SignalTypeProperties.H"


/****************************************************************
                      EdgeFactory methods
 ****************************************************************/

PhasedEdge *EdgeFactory::newPhasedEdge(double scorePhase0,double scorePhase1,
				       double scorePhase2,SignalPtr left,
				       SignalPtr right)
{
  return new PhasedEdge(scorePhase0,scorePhase1,scorePhase2,left,right);
}


NonPhasedEdge *EdgeFactory::newNonPhasedEdge(double score,SignalPtr left,
					     SignalPtr right)
{
  return new NonPhasedEdge(score,left,right);
}


/****************************************************************
                  FilteredEdgeFactory methods
 ****************************************************************/

FilteredEdgeFactory::FilteredEdgeFactory(EvidenceFilter *f)
  : filter(f)
{
  // ctor
}


FilteredEdgeFactory::~FilteredEdgeFactory() {
  delete filter;
}


PhasedEdge *FilteredEdgeFactory::newPhasedEdge(double scorePhase0,
					       double scorePhase1,
					       double scorePhase2,
					       SignalPtr left,
					       SignalPtr right)
{
  SignalType leftType=left->getSignalType(), rightType=right->getSignalType();
  ContentType T=
    SignalTypeProperties::global.getContentType(leftType,rightType);
  int leftPos=left->getConsensusPosition();
  int rightPos=right->getConsensusPosition();
  if(isIntron(T)) {
    //cout<<"******* "<<leftPos<<" "<<rightPos+2<<endl;
    if(!filter->intronSupported(leftPos,rightPos+2)) {
      //cout<<"\tREJECTING INTRON "<<leftPos<<"-"<<rightPos+2<<endl;
      return NULL;
    }
    //else cout<<"supporting intron "<<leftPos<<"-"<<rightPos+2<<endl;
  }
  else if(isCoding(T)) {
    if(endsIntron(leftType)) leftPos+=2;
    if(beginsIntron(rightType)) rightPos-=3;

    //cout<<"CHECKING PILEUP FOR INTERVAL "<<leftPos<<"-"<<rightPos+3<<endl;


    //if(rightType==TAG) cout<<"checking exon "<<leftPos<<" to "<<rightPos+3<<endl;
    //if(filter->exonSupported(leftPos,rightPos+3)) return NULL;


  }
  else INTERNAL_ERROR; // intergenic -- should not happen
  //if(T==INTRON) cout<<"INTRON EDGE "<<leftPos<<"-"<<rightPos<<endl;
  return new PhasedEdge(scorePhase0,scorePhase1,scorePhase2,left,right);
}


void FilteredEdgeFactory::setEvidence(EvidenceFilter *f)
{
  delete filter;
  filter=f;
}