Bio::EnsEMBL::Analysis::Tools::FeatureFactory

  my $featurefactory = new Bio::EnsEMBL::Analysis::Tools::FeatureFactory;

  my $feature_pair = $featurefactory->create_feature_pair(1, 13, -1, 300, 
                                                          45, 56, 1 Q12732,
                                                          95, 2.3e-35, '',
                                                          $slice,
                                                          $analysis); 
  $featurefactory->validate($feature_pair);

  my ($self, $mf, $code, $name, $description, $value) = @_;

  $mf->add_Attribute ( Bio::EnsEMBL::Attribute->new
    (-CODE   => $code,
     -NAME   => $name,
     -DESCRIPTION => $description,
     -VALUE  => $value,
    )
                     );

  my ($self, $mf, $code, $name, $description, $longest_feature) = @_;

  $mf->add_MiscSet ( Bio::EnsEMBL::MiscSet->new
    (-CODE   => $code,
     -NAME   => $name,
     -DESCRIPTION => $description,
     -VALUE  => $longest_feature,
    )
                     );

    my ($self, $start, $end, $strand, $score, $hstart, $hend, 
        $hstrand, $hseqname, $percent_id, $p_value, $seqname,
        $slice, $analysis, $positive_matches, $identical_matches) = @_;
    my $fp = Bio::EnsEMBL::FeaturePair->new(
                                            -start    => $start,
                                            -end      => $end,
                                            -strand   => $strand,
                                            -hstart   => $hstart,
                                            -hend     => $hend,
                                            -hstrand  => $hstrand,
                                            -percent_id => $percent_id,
                                            -score    => $score,
                                            -p_value  => $p_value,
                                            -hseqname => $hseqname,
                                            -analysis => $analysis,
                                           );

    $fp->seqname($seqname);
    $fp->slice($slice);
    $fp->positive_matches($positive_matches);
    $fp->identical_matches($identical_matches);
    return $fp;

  my ($self, $dbID) = @_;
  my $m = Bio::EnsEMBL::Map::Marker->new();
  $m->dbID($dbID);
  return $m;

  my ($self, $start, $end, $strand, $marker,
     $seqname, $slice, $analysis) = @_;
  my $mf = Bio::EnsEMBL::Map::MarkerFeature->new();
  $mf->start($start);
  $mf->end($end);
  $mf->strand($strand);
  $mf->marker($marker);
  $mf->seqname($seqname);
  $mf->slice($slice);
  $mf->analysis($analysis);
  return $mf;
}


#validation methods#

  my ($self, $start, $end, $strand, $slice) = @_;
  
  my $mf = Bio::EnsEMBL::MiscFeature->new
    (
     -start => $start,
     -end => $end,
     -strand => $strand,
     -slice => $slice,
    );
  return $mf;

  my ($self, $start, $end, $strand, $score, $pvalue, $phase, $seqname,
      $slice, $analysis) = @_;
  my $exon = Bio::EnsEMBL::PredictionExon->new
    (
     -start => $start,
     -end => $end,
     -strand => $strand,
     -score => $score,
     -p_value => $pvalue,
     -phase => $phase,
     -slice => $slice,
     -seqname => $seqname,
     -analysis => $analysis,
     );
  return $exon;

   my ($self, $exons, $slice, $analysis) = @_;
   my $transcript = Bio::EnsEMBL::PredictionTranscript->new
     (
      -exons => $exons,
      -slice => $slice,
      -analysis => $analysis,
     );
   return $transcript;

  my ($self, $name, $class, $type, $consensus_seq, $length) = @_;
  my $repeat_consensus = Bio::EnsEMBL::RepeatConsensus->new
    (
     -name => $name,
     -length => $length,
     -repeat_class => $class,
     -repeat_consensus => $consensus_seq,
     -repeat_type => $type,
    );
  return $repeat_consensus;

  my ($self, $start, $end, $strand, $score, $repeat_start, $repeat_end,
      $repeat_consensus, $seqname, $slice, $analysis) = @_;

  my $repeat_feature = Bio::EnsEMBL::RepeatFeature->new
    (
     -start            => $start,
     -end              => $end,
     -strand           => $strand,
     -slice            => $slice,
     -analysis         => $analysis,
     -repeat_consensus => $repeat_consensus,
     -hstart           => $repeat_start,
     -hend             => $repeat_end,
     -score            => $score,
     -seqname          => $seqname, 
    );
  return $repeat_feature;

  my ($self, $start, $end, $strand, $score, $display_label,
      $seqname, $slice, $analysis) = @_;
  my $simple_feature = Bio::EnsEMBL::SimpleFeature->new
    (
     -start => $start,
     -end => $end,
     -strand => $strand,
     -score => $score,
     -display_label => $display_label,
     -seqname => $seqname,
     -slice => $slice,
     -analysis => $analysis,
    );
  return $simple_feature;

  my ($class,@args) = @_;
  my $self = bless {},$class;
  return $self;
}

#feature creation methods#

  my ($self, $feature) = @_;
  # print STDERR "validating: ".$feature->start."-".$feature->end.":".$feature->hseqname."::".$feature->hstart."-".$feature->hend."\n";
  my @error_messages;
  if(!$feature){
    throw("Can't validate a feature without a feature ".
          "FeatureFactory::validate");
  }
  if(!($feature->isa('Bio::EnsEMBL::Feature'))){
    throw("Wrong type ".$feature." must be a Bio::EnsEMBL::Feature ".
          "object FeatureFactory::validate");
  }
  if(not defined $feature->slice){
    my $string = "No slice defined";
    push(@error_messages, $string);
  }
  if(not defined $feature->analysis){
    my $string = "No analysis defined";
    push(@error_messages, $string);
  }
  if(not defined $feature->start){
    my $string = "No start defined";
    push(@error_messages, $string); 
  }
  if(not defined $feature->end){
    my $string = "No end defined";
    push(@error_messages, $string); 
  }
  if(not defined $feature->strand){
    my $string = "No strand defined";
    push(@error_messages, $string); 
  }
  if($feature->start > $feature->end){
    my $string = "Start is greater than end ".$feature->start." ".
      $feature->end;
    push(@error_messages, $string); 
  }
  if(@error_messages > 0){
    print STDERR join("\n", @error_messages);
    throw("Invalid feature ".$feature." FeatureFactory:validate");
  }

  my ($self, $pt, $attach_to_exons) = @_;
  if(!$pt){
    throw("Can't validate a prediction transcript without a ".
          "prediction transcript ".
          "FeatureFactory:validate_prediction_transcript");
  }
  if(!($pt->isa('Bio::EnsEMBL::PredictionTranscript'))){
    throw("Wrong type ".$pt." must be a Bio::EnsEMBL::PredictionTranscript".
          "FeatureFactory:validate_prediction_transcript");
  }
  my @exons = @{$pt->get_all_Exons};
  if(@exons == 0){
    throw("problem ".$pt." has no exons");
  }
  foreach my $e(@exons){
    if($attach_to_exons){
      $e->slice($pt->slice) if(!$e->slice);
      $e->analysis($pt->analysis) if(!$e->analysis);
    }
    $self->validate($e);
  }
  $self->validate($pt);
  my $tseq;
  eval{
    $tseq = $pt->translate;
  };
  if(!$tseq){
    throw($pt." translate didn't return a sequence $@");
  }
  if ($tseq->seq =~ /\*/) {
    my $msg = $pt." doesn't have a valid translation ".$tseq->seq;
    $msg .= "\n$@" if($@);
    throw($msg);
  }
  return 1;
}

1;

  Arg [1]   : Bio::EnsEMBL::Analysis::Tools::FeatureFactory
  Arg [2]   : int, start,
  Arg [3]   : int, end
  Arg [4]   : int, strand
  Arg [5]   : int, score
  Arg [6]   : float, p value
  Arg [7]   : int, phase
  Arg [8]   : string, seqname
  Arg [9]   : Bio::EnsEMBL::Slice
  Arg [10]  : Bio::EnsEMBL::Analysis
  Function  : create a Bio::EnsEMBL::PredictionExon
  Returntype: Bio::EnsEMBL::PredictionExon
  Exceptions: 
  Example   :