lib/CXGN/Cview/Chromosome.pm

   1
   2
   3 =head1 NAME
   4
   5 CXGN::Cview::Chromosome - a class for drawing chromosomes.
   6
   7 =head1 DESCRIPTION
   8
   9 Inherits from L<CXGN::Cview::ImageI>. The chromosome can be defined by adding markers as CXGN::Cview::Marker objects, using the add_marker() function. An object defining a ruler (CXGN::Cview::Ruler) can be obtained by calling the get_ruler() function. The length of the chromosome is either defined implicitly by the marker with the highest cM position, or explicitly using the set_length() function. The placement of the chromosome is defined by CXGN::Cview::ImageI defined functions such as set_horizontal_offset(), which defines the mid-line of the chromosome, and set_vertical_offset(), which defines the top edge.
  10
  11 Chromosomes can be rendered either in full or in section. The sections can start at cM positions other than 0 and are rendered slightly differently. Use set_section() to define the section.
  12
  13 The render() function will render the chromosome on the GD::Image supplied. It calls the subroutines to draw the chromosomes, lays out the marker labels and then calls the render function on each marker object.
  14
  15 Certain aspects of the appearance of the chromosome can be changed. For example, the color of the chromosome can be changed using set_color(). Labels can be rendered on the left or on the right of the chromosome, using set_labels_right() or set_labels_left().
  16
  17 Markers with the highest LOD score or rendered last, such that they will appear on the chromosome at the expense of lower scoring markers.
  18
  19 Chromosome areas can be rendered clickable using the function rasterize().
  20
  21 =head1 SEE ALSO
  22
  23 See also the documentation in L<CXGN::Cview> and L<CXGN::Cview::ImageI>.
  24
  25 =head1 AUTHOR(S)
  26
  27 Lukas Mueller (lam87@cornell.edu)
  28
  29 =head1 FUNCTIONS
  30
  31 CXGN::Cview::Chromosome has the following methods:
  32
  33 =cut
  34
  35 use strict;
  36 use CXGN::Cview::ImageObject;
  37 use CXGN::Cview::Marker;
  38 use CXGN::Cview::Marker::SequencedBAC;
  39 use CXGN::Cview::Ruler;
  40 use CXGN::Cview::Ruler::PachyteneRuler;
  41 use CXGN::Cview::Chromosome::BarGraph;
  42
  43
  44 package CXGN::Cview::Chromosome;
  45
  46 use base qw(CXGN::Cview::ImageObject);
  47
  48 use GD;
  49
  50 =head2 function new()
  51
  52 my $c = CXGN::Cview::Chromosome -> new( chr number, height in pixels, horizontal offset, vertical offset, [start cM], [end cM])
  53
  54 Creates a new chromosome object. The horizontal offset denotes the offset of the chromosome mid-line. The vertical offset defines the upper end of the chromosome. Note that some renditions of the chromosome will add round edges on the top and on the bottom, so that the rounded top position will be smaller than the vertical offset.
  55
  56 Optionally, start_cM and end_cM can be supplied, which will set the start and end in cM for a chromosome section. The chromosome will be rendered as a section, i.e, the ends will be flat instead of rounded.
  57
  58 =cut
  59
  60 sub new {
  61     my $class = shift;
  62
  63     my $chr_nr = shift;
  64     my $height = shift;
  65     my $x = shift;
  66     my $y = shift;
  67     my $start = shift;
  68     my $end = shift;
  69
  70     my $self = $class -> SUPER::new($x, $y, $height);
  71
  72     $self -> set_start_cM($start); # if a chromosome section, where the section starts, in cM
  73     $self -> set_end_cM($end); # if a chromosome section, where the section ends, in cM
  74
  75     $self -> {markers} = ();
  76
  77     $self->set_labels_right();
  78     $self -> set_width(20); # default width
  79     $self -> {curved_height} = $self->get_width();
  80
  81     $self->{chr_nr}=$chr_nr;
  82     $self->set_name($chr_nr);
  83
  84     $self -> {font} = GD::Font->Small();
  85     # set default colors
  86     $self -> set_horizontal_offset($x);
  87     $self -> set_vertical_offset($y);
  88     $self -> set_color(200, 150, 150);
  89     $self -> set_hilite_color(255, 255, 0);
  90     $self -> set_outline_color(0,0,0);
  91     $self -> set_hide_marker_offset();
  92     $self -> set_units('cM');
  93     $self -> set_ruler( CXGN::Cview::Ruler->new($self->get_horizontal_offset(), $self->get_vertical_offset(), $self->get_height(), 0, $self->get_length()) );
  94 #    don't do this - will cause deep recursion... $self -> set_bargraph( CXGN::Cview::Chromosome::BarGraph->new($self->get_horizontal_offset(), $self->get_vertical_offset(), $self->get_height(), 0, $self->get_length()));
  95     $self -> hide_bargraph(); # by default, do not show the bar graph.
  96     return $self;
  97 }
  98
  99 =head2 function set_height()
 100
 101     $chr->set_height($height)
 102
 103 Sets the height of the chromosome in pixels. Recalculates all the scaling information.
 104 Implemented in superclass.
 105
 106 =cut
 107
 108
 109 =head2 function get_height()
 110
 111     $height = $chr ->get_height()
 112
 113 Gets the height of the chromosome in pixels. Implemented in the superclass.
 114
 115 =cut
 116
 117
 118 =head2 function set_length()
 119
 120 sets the length in map units [cM].
 121
 122 This can also be automatically determined if not set manually, to the offset of the marker with the highest map unit value.
 123
 124 =cut
 125
 126
 127 sub set_length {
 128     my $self=shift;
 129     $self->{chromosome_length_cM}=shift;
 130 }
 131
 132 =head2 function get_length()
 133
 134 gets the length of the chromosome in map units.
 135
 136 =cut
 137
 138 sub get_length {
 139     my $self=shift;
 140
 141     return $self->{chromosome_length_cM};
 142 }
 143
 144
 145 =head2 function get_units()
 146
 147  Synopsis:
 148  Arguments:
 149  Returns:
 150  Side effects:
 151  Description:
 152
 153 =cut
 154
 155 sub get_units {
 156     my $self=shift;
 157     return $self->{units};
 158 }
 159
 160 =head2 function set_units()
 161
 162  Synopsis:
 163  Arguments:
 164  Returns:
 165  Side effects:
 166  Description:
 167
 168 =cut
 169
 170 sub set_units {
 171     my $self=shift;
 172     my $units = shift;
 173     $self->{units} = $units;
 174 }
 175
 176 =head2 function get_ruler()
 177
 178  Synopsis:
 179  Arguments:
 180  Returns:
 181  Side effects:
 182  Description:
 183
 184 =cut
 185
 186 sub get_ruler {
 187     my $self=shift;
 188     return $self->{ruler};
 189 }
 190
 191 =head2 function set_ruler()
 192
 193  Synopsis:
 194  Arguments:
 195  Returns:
 196  Side effects:
 197  Description:
 198
 199 =cut
 200
 201 sub set_ruler {
 202     my $self=shift;
 203     $self->{ruler}=shift;
 204 }
 205
 206 =head2 accessors set_bargraph(), get_bargraph()
 207
 208   Property:     an associated bar graph with this chromosome
 209                 The bargraph is a CXGN::Cview::Chromosome::BarGraph
 210                 object. The default is no bar graph, ie, an empty
 211                 bar graph is initialized in the constructor.
 212
 213   Side Effects:
 214   Description:
 215
 216 =cut
 217
 218 sub get_bargraph {
 219     my $self=shift;
 220     return $self->{bargraph};
 221 }
 222
 223 sub set_bargraph {
 224     my $self=shift;
 225     $self->{bargraph}=shift;
 226 }
 227
 228
 229 =head2 functions show_bargraph(), hide_bargraph()
 230
 231   Synopsis:
 232   Arguments:
 233   Returns:
 234   Side effects:
 235   Description:
 236
 237 =cut
 238
 239 sub show_bargraph {
 240     my $self = shift;
 241     $self->{show_bargraph}=1;
 242 }
 243
 244 sub hide_bargraph {
 245     my $self = shift;
 246     $self->{show_bargraph}=0;
 247 }
 248
 249 =head2 function set_section()
 250
 251     $chr->set_section($start_in_map_units, $end_in_map_units);
 252
 253 Defines the chromosome as a section. The section starts at the start coordinate in map units, and ends at the end coordinate in map units. Chromosomes that are sections are rendered differently than full chromosomes. The section will be rendered so that it fills the entire height of the chromosome as defined with new or set_height, and the top edge will be drawn at the horizontal and vertical offset defined in the new call or with set_horizonatal_offset and set_vertical_offset.
 254
 255 =cut
 256
 257
 258
 259 sub set_section {
 260     my $self = shift;
 261     $self -> set_start_cM(shift);
 262     $self -> set_end_cM(shift);
 263     $self -> {is_section} =1;
 264 }
 265
 266 =head2 function get_section()
 267
 268     $flag = $chr->is_section()
 269
 270 Returns true if the chromosome $chr is a section.
 271
 272 =cut
 273
 274 sub is_section {
 275     my $self = shift;
 276     return $self -> {is_section};
 277 }
 278
 279 =head2 function set_hilite()
 280
 281 $chr->set_hilite(start_coord, end_coord)
 282
 283 Highlights the region of the chromosome between start_coord and end_coord with the hilite_color (which can be set with set_hilite_color, see below).
 284
 285 =cut
 286
 287 sub set_hilite {
 288     my $self = shift;
 289     $self->{hilite_start}=shift;
 290     $self->{hilite_end}=shift;
 291 }
 292
 293 =head2 function set_hilite_color()
 294
 295 $chr->set_hilite($red_channel, $green_channel, $blue_channel)
 296
 297 Sets the hilite color for chromosome highlighting. Three values between 0 and 255 are required for defining red, green and blue channels. The default color is yellow (255, 255,0)
 298
 299 =cut
 300
 301 sub set_hilite_color {
 302     my $self = shift;
 303     $self->{hilite_color}[0]=shift;
 304     $self->{hilite_color}[1]=shift;
 305     $self->{hilite_color}[2]=shift;
 306 }
 307
 308 sub get_hilite_color {
 309     my $self = shift;
 310     return @{$self->{hilite_color}};
 311 }
 312
 313
 314
 315 =head2 function set_color()
 316
 317 Sets the chromosome outline color. Three values between 0 and 255 are required for defining red, green and blue channels. The default color is 0,0,0, which is black. This function is defined in the parent class.
 318
 319 =cut
 320
 321 sub set_outline_color {
 322     my $self = shift;
 323     $self->{outline_color}[0]=shift;
 324     $self->{outline_color}[1]=shift;
 325     $self->{outline_color}[2]=shift;
 326 }
 327
 328
 329 =head2 function set_caption()
 330
 331 Sets the caption of the chromosome. The caption will be drawn centered on the top of the chromosome. Usually, the chromosome number should be displayed.
 332
 333 =cut
 334
 335
 336 sub set_caption {
 337     my $self = shift;
 338     $self->{caption}=shift;
 339 }
 340
 341 sub get_caption {
 342     my $self = shift;
 343     return $self->{caption};
 344 }
 345
 346 =head2 function set_labels_left()
 347
 348 Causes the labels to be displayed on the left side of the chromosome.
 349
 350 =cut
 351
 352 sub set_labels_left {
 353     my $self = shift;
 354     $self->{label_side} = "left";
 355 }
 356
 357 =head2 function set_labels_right()
 358
 359 Causes the labels to be displayed on the right side of the chromosome.
 360
 361 =cut
 362
 363 sub set_labels_right {
 364     my $self = shift;
 365     $self->{label_side} = "right";
 366 }
 367
 368 =head2 function set_labels_none()
 369
 370 Causes the labels not to be displayed for the whole chromosome.
 371
 372 =cut
 373
 374 sub set_labels_none {
 375     my $self = shift;
 376     $self -> {label_side} = "";
 377 }
 378
 379 =head2 function get_label_side()
 380
 381   Synopsis:
 382   Arguments:
 383   Returns:
 384   Side effects:
 385   Description:
 386
 387 =cut
 388
 389 sub get_label_side {
 390     my $self = shift;
 391     return $self->{label_side};
 392 }
 393
 394
 395 =head2 function set_display_marker_offset()
 396
 397 Causes the marker offsets to be displayed on the opposite side of the labels.
 398
 399 =cut
 400
 401 sub set_display_marker_offset {
 402     #
 403     # is set, the marker offset in cM will be displayed on the opposite side of the label
 404     #
 405     my $self = shift;
 406     $self -> {display_marker_offset} = 1;
 407 }
 408
 409 sub set_hide_marker_offset {
 410     my $self = shift;
 411     $self -> {display_marker_offset} = 0;
 412 }
 413
 414 =head2 function render()
 415
 416     $chr-> render($image);
 417
 418 This function is called to render the chromosome and recursively calls all the rendering functions of the objects it contains. The image parameter is an GD image object. Usually, you should not have to call this function, but the MapImage object calls this function for you if you render a map.
 419
 420 =cut
 421
 422 sub render {
 423     my $self = shift;
 424     my $image = shift;
 425
 426     $self -> layout();
 427     $self -> draw_chromosome($image);
 428     $self -> render_markers($image);
 429 }
 430
 431 =head2 function render_markers()
 432
 433   Synopsis:
 434   Arguments:
 435   Returns:
 436   Side effects:
 437   Description:  This function renders the markers of the chromosome object.
 438                 The important thing is to render the markers such that the highest
 439                 load score marker is rendererd last.
 440
 441 =cut
 442
 443 sub render_markers {
 444     my $self = shift;
 445     my $image = shift;
 446
 447     my @markers = $self->get_markers();
 448
 449     foreach my $lod (-1,0,1,2,3) {
 450
 451         foreach my $m (@markers) {
 452
 453             if (!$m->isa("CXGN::Cview::Marker::SequencedBAC")) {
 454                 if ($m->get_confidence()==$lod) {
 455                     $m -> render($image);
 456                 }
 457                 else {
 458
 459                 }
 460             }
 461
 462         }    }
 463
 464     # render highlighted markers again to prevent clobbering
 465     foreach my $m (@markers) {
 466         if ($m->is_visible() && $m->get_hilited()) {
 467             $m->render($image);
 468         }
 469     }
 470
 471
 472     foreach my $m (@markers) {
 473         if ($m->isa("CXGN::Cview::Marker::SequencedBAC")) {
 474             $m->get_label()->set_text_color(200,200,80);
 475             $m->get_label()->set_line_color(200,200,80);
 476             $m->set_color(255,255,0);
 477             $m->render($image);
 478         }
 479     }
 480
 481 }
 482
 483
 484 # =head2 function render_labels
 485
 486 #   Synopsis:
 487 #   Arguments:
 488 #   Returns:
 489 #   Side effects:
 490 #   Description:
 491
 492 # =cut
 493
 494 # sub render_labels {
 495 #     my $self = shift;
 496 #     my $image = shift;
 497 #     foreach my $m ($self->get_markers()) {
 498 #       if ($m->is_visible() && $m->get_label()->get_hilited()) {
 499 #           $m->get_label()->render($image);
 500 #       }
 501 #     }
 502
 503 # }
 504
 505
 506 sub get_enclosing_rect {
 507     my $self = shift;
 508     return (int($self->get_horizontal_offset()-$self->get_width()/2), $self->get_vertical_offset(), $self->get_horizontal_offset()+int($self->get_width()/2), $self->get_vertical_offset()+$self->{height});
 509 }
 510
 511 =head2 function rasterize()
 512
 513 Causes the chromosome to be rasterized in the MapImage tags. A scaffold of rectangular areas is overlaid on the chromosome that can be used to link to something to this part of the chromosome. The link is supplied through set_rasterize_link. The parameter gives the size of the raster in cM. With the parameter set to zero, no rastering occurs.
 514
 515 =cut
 516
 517 sub rasterize {
 518     # this function sets the rasterize variable, get_image_map then rasterizes the chromosome if necessary.
 519     my $self = shift;
 520     if (@_) {
 521         $self->{rasterize}=shift;
 522    }
 523     return $self->{rasterize};
 524 }
 525
 526 sub set_rasterize_link {
 527     my $self = shift;
 528     $self->{rasterize_link} = shift;
 529 }
 530
 531 # the rasterize link has to be of the format http://url.domain.etc/etc/program?parameter=values&parameter=values&cM=
 532 # rasterizatio will add the number of cM where clicked at the end of the link.
 533 sub get_rasterize_link {
 534     my $self = shift;
 535     if (!exists($self->{rasterize_link}) || !defined($self->{rasterize_link})) {
 536         $self->{rasterize_link}="";
 537     }
 538     return $self->{rasterize_link};
 539 }
 540
 541 =head2 function get_image_map()
 542
 543 Gets the image map for the chromosome and all contained objects within chromosome. This is normally called by the MapImage object.
 544
 545 =cut
 546
 547 sub get_image_map {
 548     my $self = shift;
 549     my $coords = join ",", ($self -> get_enclosing_rect());
 550     my $string = "";;
 551
 552     if ($self->get_url()) {  $string =  "<area shape=\"rect\" coords=\"".$coords."\" href=\"".$self->get_url()."\" alt=\"\" />";}
 553     foreach my $m (($self->get_markers())) {
 554         if ($m->is_visible()) {
 555             $string .= $m -> get_image_map();
 556         }
 557     }
 558     if ($self->rasterize() && $self->get_length()>0) {
 559         my $raster = $self->get_length()/20;#$self->{rasterize}; # cM
 560         my $steps = ($self->get_length()/$raster);
 561
 562         my $halfwidth = ($self->get_width()/2);
 563         my $x = $self->get_horizontal_offset();
 564         my $y = $self->get_vertical_offset();
 565         my $box_pixel_height = $self->get_height()/$steps;
 566
 567         for (my $i=0; $i<=($steps+1); $i++) {
 568             my $cM = $i*$raster;
 569             my $pixels = $self->mapunits2pixels($cM)+$y;
 570
 571             $string .="<area shape=\"rect\" coords=\"".int($x-$halfwidth).",".int($pixels).",".int($x+$halfwidth).",".int($pixels+$box_pixel_height)."\" href=\"".$self->get_rasterize_link().$cM."\" alt=\"\" />\n";
 572         }
 573     }
 574         return $string;
 575
 576 }
 577
 578 sub _sort_by_position {
 579     return ($a->get_offset() <=> $b->get_offset);
 580 }
 581
 582 =head2 function sort_markers()
 583
 584   Synopsis:     $c->sort_markers()
 585   Arguments:    none
 586   Returns:      nothing
 587   Side effects: sorts the markers according to their position
 588                 in the internal datastructure. This is required
 589                 for proper rendering of the marker labels; if
 590                 the markers are added in sequence, calling this
 591                 is superfluous.
 592   Description:
 593
 594 =cut
 595
 596
 597
 598 sub sort_markers {
 599     my $self=shift;
 600     my @sorted_markers = sort _sort_by_position ($self->get_markers());
 601     $self->set_markers(@sorted_markers);
 602 }
 603
 604 sub _calculate_scaling_factor {
 605     my $self = shift;
 606
 607     $self -> _calculate_chromosome_length();
 608     if ($self->get_length()==0) { return 0; }
 609
 610     $self->{scaling_factor}=($self->get_height()/$self->get_length());
 611
 612     #print STDERR "calculating scaling factor. height in pixels: $self->{height} chromosome_length=$self->{chromosome_length_cM} scaling factor: $self->{scaling_factor}\n";
 613
 614     return $self->{scaling_factor};
 615 }
 616
 617 sub get_scaling_factor {
 618     my $self = shift;
 619     if (!exists($self->{scaling_factor})) {
 620         $self->{scaling_factor}=0;
 621         warn "[CXGN::Cview::Chromosome] WARNING! Scaling factor is 0.\n";
 622     }
 623     return $self->{scaling_factor};
 624 }
 625
 626 =head2 function add_marker()
 627
 628     $chr->add_marker($m);
 629
 630 Adds the marker object $m to the chromosome.
 631
 632 =cut
 633
 634 sub add_marker {
 635     my $self = shift;
 636     my $m = shift;
 637     push @{$self->{markers}}, $m;
 638 }
 639
 640 =head2 function get_markers()
 641
 642     my @m = $chr -> get_markers();
 643
 644 Gets all the markers in the chromosome as an array.
 645
 646 =cut
 647
 648 sub get_markers {
 649     my $self = shift;
 650     if (!defined($self->{markers})) { return (); }
 651
 652     if (defined($self->get_start_cM()) && defined($self->get_end_cM())) {
 653         my @markers = ();
 654
 655         foreach my $m (@{$self->{markers}}) {
 656             if ( ($m->get_offset() >= $self->get_start_cM()) &&
 657                  ($m->get_offset() <= $self->get_end_cM()) ) {
 658                 push @markers, $m;
 659             }
 660         }
 661         return @markers;
 662     }
 663     return @{$self->{markers}};
 664 }
 665
 666 sub set_markers {
 667     my $self =shift;
 668     @{$self->{markers}} = @_;
 669 }
 670
 671 =head2 accessors set_start_cM(), get_start_cM()
 672
 673   Property:
 674   Setter Args:
 675   Getter Args:
 676   Getter Ret:
 677   Side Effects:
 678   Description:
 679
 680 =cut
 681
 682 sub get_start_cM {
 683     my $self=shift;
 684     if (!exists($self->{start_cM}) || !defined($self->{start_cM})) { $self->{start_cM}=0; }
 685     return $self->{start_cM};
 686 }
 687
 688 sub set_start_cM {
 689     my $self=shift;
 690     $self->{start_cM}=shift;
 691 }
 692
 693 =head2 accessors set_end_cM(), get_end_cM()
 694
 695   Property:
 696   Setter Args:
 697   Getter Args:
 698   Getter Ret:
 699   Side Effects:
 700   Description:
 701
 702 =cut
 703
 704 sub get_end_cM {
 705     my $self=shift;
 706     if (!exists($self->{end_cM}))  { $self->{end_cM}=0; }
 707     return $self->{end_cM};
 708 }
 709
 710 sub set_end_cM {
 711     my $self=shift;
 712     $self->{end_cM}=shift;
 713 }
 714
 715
 716
 717 sub get_markers_in_interval {
 718     my $self = shift;
 719     my $start = shift;  # start in cM
 720     my $end = shift;    # end position in cM
 721     if (!$start && !$end) { $start = 0; $end = $self -> get_length()+1 ; }
 722     my @markers;
 723     foreach my $m (@{$self->{markers}}) {
 724         if ($m -> get_offset() >= $start && $m->get_offset() <= $end) {
 725             push @markers, $m;
 726         }
 727     }
 728     return @markers;    # returns all the markers in between start and end
 729 }
 730
 731 sub get_frame_markers {
 732     my $self = shift;
 733     my @framemarkers = ();
 734     foreach my $m (@{$self->{markers}}) {
 735         if ($m->is_frame_marker()) {
 736             push @framemarkers, $m;
 737         }
 738     }
 739     return @framemarkers;
 740 }
 741
 742 sub get_markers_ref {
 743     my $self = shift;
 744     return \@{$self->{markers}};
 745 }
 746
 747 sub layout {
 748     my $self = shift;
 749     $self->_calculate_chromosome_length();
 750     $self->_calculate_scaling_factor();
 751     $self -> distribute_labels();
 752     $self -> distribute_label_stacking();
 753
 754 }
 755
 756 sub _calculate_chromosome_length {
 757     my $self = shift;
 758     my $length = 0;
 759
 760     # get chromosome length in cM.
 761     #
 762     # if it is a section, we return the length of the section, as defined by start_cM and end_cM
 763     #
 764     if ($self->is_section()) {
 765         if ($self->get_end_cM()>$self->{chromosome_length_cM}) {
 766             $self->get_end_cM($self->{chromosome_length_cM});
 767         }
 768         $self->{chromosome_length_cM}=$self->get_end_cM()-$self->get_start_cM();
 769         return $self->{chromosome_length_cM};
 770     }
 771
 772     # it may be that chromosome_length has been manually set with set_length.
 773     #
 774     if ($self->get_length()) {
 775         return $self->get_length();
 776     }
 777
 778     # otherwise, we get the marker with the highest cM position.
 779     # the length may have been set already by set_length...
 780     else {
 781         foreach my $m (@{$self->{markers}}) {
 782             my $offset = $m -> get_offset();
 783             if ($offset > $length) { $length = $offset; }
 784         }
 785         $self->{chromosome_length_cM} = $length;
 786
 787         return $self->{chromosome_length_cM};
 788     }
 789
 790     # otherwise return some default length
 791     #
 792     return 10;
 793
 794 }
 795
 796 sub get_chromosome_length {
 797     # same as get_length. Deprecated.
 798     my $self = shift;
 799     return $self->{chromosome_length_cM};
 800 }
 801
 802 =head2 function mapunits2pixels()
 803
 804     my $pixels = $chr->mapunits2pixels($cM_pos);
 805
 806 Gets the number of pixels the cM value corresponds to. Note that you have to add the vertical chromosome offset (get_vertical_offset) to this number the get the actual image coordinates.
 807
 808 =cut
 809
 810
 811 sub mapunits2pixels {
 812     my $self = shift;
 813     my $cM = shift;
 814
 815     if (! $cM) { $cM=0; }
 816     my $pixels = ($cM - $self->get_start_cM()) * $self->get_scaling_factor();
 817     #print STDERR "Scaling factor: $self->{scaling_factor} cM: $cM = $pixels pixels\n";
 818     return $pixels;
 819 }
 820
 821 =head2 function get_pixels_cM()
 822
 823     my $cM = $chr->get_pixels_cM($pixels);
 824
 825 Gets the number of cM that the number of $pixels correspond to. Note that you have to substract the vertical chromosome offset (get_vertical_offset) from the pixels this number the get the correct number of cM.
 826
 827 =cut
 828
 829 sub get_pixels_cM {
 830     my $self = shift;
 831     my $pixels = shift;
 832     my $cM = ($pixels / $self->{scaling_factor}) + $self->get_start_cM();
 833 }
 834
 835
 836
 837 sub is_visible {
 838     my $self = shift;
 839     my $cM = shift;
 840
 841     if ($self->is_section()) {
 842         if ($cM >= $self->get_start_cM() && $cM <= $self ->get_end_cM()) {
 843             return 1;
 844         }
 845         else {return 0; }
 846     }
 847     return 1;
 848 }
 849
 850
 851 =head2 function distribute_labels()
 852
 853   Synopsis:     $c->distribute_labels()
 854   Arguments:    none
 855   Returns:      distributes the labels nicely along the chromosome
 856   Side effects: changes the positions of the labels
 857   Description:  first it calculates label positions by setting the first label
 858                 to be equal to the top of the chromosome, then adjusts
 859                 all following label positions not to overlap with the
 860                 previous label, pushing them down if necessary.
 861                 Second, it calculates the label positions by setting the last
 862                 label to be equal to the end of the chromosome, and iterates
 863                 through all labels not to overlap with the previous label, if
 864                 necessary, pushing it up. To calculate the final label
 865                 position, it takes the average of the downwards and the
 866                 upwards iterations through the labels. Note that the labels need
 867                 to be ordered for this to work.
 868                 this function was renamed slightly (_ omitted) and refactored
 869                 such that left labels and right labels are distributed
 870                 separately.
 871
 872 =cut
 873
 874 sub distribute_labels {
 875     my $self = shift;
 876     $self->_distribute_labels("left");
 877     $self->_distribute_labels("right");
 878
 879 }
 880
 881
 882 sub _distribute_labels {
 883      my $self = shift;
 884      my $side = shift;
 885
 886      my @m = $self->get_markers();
 887      my $lastlabelpos = 0;
 888
 889      # calculate the downwards offsets
 890      #
 891      my %downwards=();
 892
 893      if (!@m) { return; }
 894
 895      foreach my $m (@m) {
 896          #if ($m->get_label_side() !~ /right|left/i) { die "Label side is not set correctly for marker ".$m->get_name()."\n"; }
 897          if ($m->is_visible() && $m->is_label_visible() && ($m->get_label_side() eq "$side")) { # || !$m->get_label_side())) {
 898              my $cM= $m->get_offset();
 899              my $labelpos = $self->mapunits2pixels($cM)+$self->get_vertical_offset();
 900              my $labelheight = $m -> get_label_height();
 901              #print STDERR "label height: $labelheight\n";
 902
 903              if (($labelpos-$labelheight)<$lastlabelpos) {
 904                  $labelpos = $lastlabelpos+$labelheight;
 905                  if (exists($downwards{$m->get_name()})) { warn "CATASTROPHE: Duplicate marker name ".($m->get_name())."\n"; }
 906                  $downwards{$m->get_name()} = $labelpos;
 907              }
 908              else {
 909                  $downwards{$m->get_name()}=$labelpos;
 910              }
 911              $lastlabelpos = $labelpos;
 912          }
 913      }
 914
 915      # calculate the upwards offsets
 916      #
 917      my %upwards = ();
 918      my $toplabelpos = $self->get_vertical_offset()+$self->get_height()+12+$m[-1]->get_label_height();
 919      foreach my $m (reverse(@m))  {
 920          if($m->is_visible() && $m->is_label_visible() && $m->get_label_side() eq "$side") {
 921              my $cM=$m->get_offset();
 922              my $labelpos = $self->mapunits2pixels($cM)+$self->get_vertical_offset();
 923              #print STDERR "VERTICAL OFFSET = ".$self->get_vertical_offset()."\n";
 924              my $labelheight= $m->get_label_height();
 925 #            print STDERR $m->get_name()." offset = $cM ID=".$m->get_id()."\n";
 926              if (($labelpos+$labelheight)>$toplabelpos) {
 927                  $labelpos = $toplabelpos-$labelheight;
 928                  if (!$m->get_name()) { warn "CATASTROPHE: Didn't get name on marker ".$m->get_id()."\n"; }
 929                  if (exists($upwards{$m->get_name})) { warn "CATASTHROPHE: duplicate marker name ".$m->get_name()."\n"; }
 930                  $upwards{$m->get_name()} = $labelpos;
 931              }
 932              else {
 933                  $upwards{$m->get_name()}=$labelpos;
 934              }
 935              $toplabelpos = $labelpos;
 936          }
 937      }
 938
 939      # load into marker objects
 940      #
 941      foreach my $m (@m) {
 942          if ($m->get_label_side() eq "$side") {
 943              my $marker_name = $m -> get_name();
 944              # test to prevent warnings...
 945              if (! $downwards{$marker_name}) { $downwards{$marker_name}=0; }
 946              if (! $upwards{$marker_name}) { $upwards{$marker_name} = 0; }
 947
 948              my $pixels = int(($downwards{$marker_name}+$upwards{$marker_name})/2);
 949              #print STDERR "Vertical pixels for marker ".$m->get_marker_name()." : $pixels.\n";
 950              $m->get_label()->set_vertical_offset($pixels);
 951          }
 952      }
 953  }
 954
 955 =head2 function distribute_label_stacking()
 956
 957   Synopsis:
 958   Arguments:    none
 959   Returns:      nothing
 960   Side effects: distributes the labels of the markers of type
 961                 RangeMarker such that they do not collide
 962                 vertically, and does this for each side
 963                 independently.
 964   Description:
 965
 966 =cut
 967
 968 sub distribute_label_stacking {
 969     my $self = shift;
 970     $self->_distribute_label_stacking("left");
 971     $self->_distribute_label_stacking("right");
 972 }
 973
 974 sub _distribute_label_stacking {
 975     my $self = shift;
 976     my $side = shift;
 977     my @tracks = ();
 978     my $maximum_stacking_level = 0;
 979     my $skipped = 0;
 980     my $TRACK_LIMIT = 20000; # exit the loop if we exceed this number of tracks.
 981
 982     # the @tracks array keeps track of which positions are already occupied by giving the
 983     # lower boundary to which the track has been filled.
 984     # it is important that the markers are sorted by position in some way
 985     # for this to look good (currently, for physical map, BACs are sorted by status, association_type
 986     # and offset, which forces sequenced BACs to be rendered next to the chromosome
 987     # and other BACs further away). All other maps should just be sorted by position.
 988     #
 989     foreach my $m ($self->get_markers()) {
 990         if ($m->is_visible() && $m->get_label_side() eq $side) {
 991
 992             # define the position of the marker
 993             my $upper_edge = $m->get_offset()-$m->get_north_range(); # the position of the top of the marker
 994             if ($upper_edge < 0 || !defined($upper_edge)) { $upper_edge = 0; }
 995             my $lower_edge = $m->get_offset()+$m->get_south_range(); # the position of the bottom of the marker
 996             if ($lower_edge < 0 || !defined($lower_edge)) { $lower_edge = 0; }
 997
 998
 999             my $current_track = 1;
1000
1001
1002             while (defined($tracks[$current_track]) && ($tracks[$current_track]>($upper_edge - $m->get_label()->get_vertical_stacking_spacing()))) {
1003
1004                 if (!exists($tracks[$current_track]) || !defined($tracks[$current_track])) { $tracks[$current_track]=0; }
1005
1006
1007                 # under certain conditions an infinite loop may be created. To prevent it, we set
1008                 # an arbitrary limit on the number of tracks supported.
1009                 if ($current_track>$TRACK_LIMIT) {
1010                     $skipped++;
1011 #                   if ($m->get_marker_name() =~ /Lpen/) {
1012 #                       print STDERR "Skipping pennellii bac ".($m->get_marker_name())." at position ".($m->get_offset())."\n";
1013 #                   }
1014                     last();
1015                 }
1016                 if ($current_track > $maximum_stacking_level) {
1017                     $maximum_stacking_level = $current_track;
1018                 }
1019                 $current_track++;
1020
1021             }
1022            # print STDERR "TRACK $current_track has lower bound $tracks[$current_track]. \n";
1023             $tracks[$current_track] = $lower_edge;
1024
1025             $m->get_label()->set_stacking_level($current_track);
1026
1027             #print STDERR "TRACKS: ".($m->get_marker_name())." [$current_track] = $tracks[$current_track], $upper_edge\n";
1028         }
1029     }
1030
1031     # here we adjust the label_spacer property of the label to be higher than the highest track.
1032     # seems like a good idea but it may produce weird effects on some maps. Maybe this should
1033     # be factored out into another subroutine so that it could be called only if desired.
1034     #
1035     foreach my $m ($self->get_markers()) {
1036         if ( ($m->get_label_side() eq "$side") && ($m->get_label()->get_stacking_height()>0)) {
1037             my $label_spacer = $m->get_label()->get_label_spacer();
1038             my $dynamic_spacer = ($maximum_stacking_level+1) * $m->get_label()->get_stacking_height()+10;
1039             if ($dynamic_spacer > $label_spacer ) {
1040                 $m->get_label()->set_label_spacer( $dynamic_spacer );
1041             }
1042         }
1043     }
1044     if ($skipped) {
1045         warn "Skipped $skipped because of space constraints (max $TRACK_LIMIT tracks).\n";
1046     }
1047 }
1048
1049 =head2 function draw_chromosome()
1050
1051     $chr->draw_chromosome($image, $type);
1052
1053 Draws the chromosome on $image. Image is a GD image. The default chromosome rendering is as a 'sausage' type chromosome. A line model is available by supplying the type parameter "line". This is usually called by the MapImage object.
1054
1055 =cut
1056
1057 sub draw_chromosome {
1058     my $self = shift;
1059     my $image = shift;
1060
1061     # draw chromosome outline
1062
1063     if (! $self->{style}) { $self->{style}=""; }
1064     if ($self->{style} eq "line") {
1065         $self->draw_chromosome_line($image);
1066     }
1067     elsif ($self->{style} eq "sausage") {
1068         $self->draw_chromosome_sausage($image);
1069     }
1070     else { $self->draw_chromosome_sausage($image); }
1071 }
1072
1073 sub draw_chromosome_line {
1074     my $self=shift;
1075     my $image=shift;
1076
1077     my $color = $image -> colorResolve($self->{color}[0], $self->{color}[1], $self->{color}[2]);
1078     #print STDERR "$self->{x}, $self->get_vertical_offset(), $self->{x}, $self->get_vertical_offset()+$self->{height}, $color\n";
1079     $image -> line($self->get_horizontal_offset(), $self->get_vertical_offset(), $self->get_horizontal_offset(), $self->get_vertical_offset()+$self->{height}, $color);
1080 }
1081
1082 sub draw_chromosome_sausage {
1083     my $self = shift;
1084     my $image = shift;
1085
1086     # allocate colors
1087     #
1088     my $outline_color = $image -> colorResolve($self->{outline_color}[0], $self->{outline_color}[1], $self->{outline_color}[2]);
1089     my $hilite_color = $image -> colorResolve($self->{hilite_color}[0], $self->{hilite_color}[1], $self->{hilite_color}[2]);
1090     my $color = $image -> colorResolve($self->{color}[0], $self->{color}[1], $self->{color}[2]);
1091
1092     my $halfwidth = $self ->{width}/2;
1093
1094     $image -> line($self->get_horizontal_offset() - $halfwidth, $self->get_vertical_offset() , $self->get_horizontal_offset()-$halfwidth, $self->get_vertical_offset()+$self->{height}, $outline_color);
1095     $image -> line($self->get_horizontal_offset() + $halfwidth, $self->get_vertical_offset() , $self->get_horizontal_offset()+$halfwidth, $self->get_vertical_offset()+$self->{height}, $outline_color);
1096     if ($self->is_section()) {
1097         my $text_color = $image -> colorResolve(50, 50, 50);
1098         $image -> line ($self->get_horizontal_offset()-$halfwidth, $self->get_vertical_offset(), $self->get_horizontal_offset()+$halfwidth, $self->get_vertical_offset(), $outline_color);
1099         $image -> line ($self->get_horizontal_offset()-$halfwidth, $self->get_vertical_offset()+$self->{height}, $self->get_horizontal_offset()+$halfwidth, $self->get_vertical_offset()+$self->{height}, $outline_color);
1100         $image -> fill($self->get_horizontal_offset(), $self->get_vertical_offset()+1, $color);
1101         my $top_label = int($self->get_start_cM()).$self->get_units();
1102         my $bottom_label = int($self ->{end_cM}).$self->get_units();
1103         $image -> string($self->{font}, $self->get_horizontal_offset()-$self->{font}->width()* length($top_label)/2, $self->get_vertical_offset()-$self->{font}->height()-3, $top_label, $text_color);
1104 $image -> string($self->{font}, $self->get_horizontal_offset() - $self->{font}->width() * length($bottom_label)/2, $self->get_vertical_offset()+$self->get_height()+3, $bottom_label,$text_color);
1105     }
1106     else {
1107         $image -> setAntiAliased($outline_color);
1108         $image -> arc ($self->get_horizontal_offset(), $self->get_vertical_offset(), $self->{width}, $self->{curved_height}, 180, 0, GD::gdAntiAliased);
1109         $image -> arc ($self->get_horizontal_offset(), $self->get_vertical_offset()+$self->{height}, $self->{width}, $self->{curved_height}, 0, 180, GD::gdAntiAliased);
1110         $image -> fill ($self->get_horizontal_offset(), $self->get_vertical_offset(), $color);
1111     }
1112
1113
1114
1115     if ($self->{hilite_start} || $self->{hilite_end}) {
1116
1117         # if we are dealing with a section, don't hilite more than the section...
1118         #
1119         if ($self->is_section()) {
1120             if ($self->{hilite_start} < $self->get_start_cM()) {
1121                 $self->{hilite_start} = $self->get_start_cM();
1122             }
1123             if ($self->{hilite_end} > $self->get_end_cM()) {
1124                 $self->{hilite_end} = $self->get_end_cM;
1125             }
1126         }
1127
1128         my $start = $self->get_vertical_offset()+$self->mapunits2pixels($self->{hilite_start});
1129         my $end   = $self->get_vertical_offset()+$self->mapunits2pixels($self->{hilite_end});
1130         $image -> rectangle($self->get_horizontal_offset()-$halfwidth,
1131                             $start,
1132                             $self->get_horizontal_offset()+$halfwidth,
1133                             $end,
1134                             $outline_color);
1135         $image -> fill ($self->get_horizontal_offset(), $start+1,  $hilite_color);
1136
1137     }
1138
1139     $self->draw_caption($image);
1140 }
1141
1142 sub draw_caption {
1143     my $self = shift;
1144     my $image = shift;
1145
1146     my $outline_color = $image -> colorResolve(
1147                                                $self->{outline_color}[0],
1148                                                $self->{outline_color}[1],
1149                                                $self->{outline_color}[2]
1150                                                );
1151     my $bigfont = GD::Font->Large();
1152     $image -> string(
1153                      $bigfont,
1154                      $self->get_horizontal_offset()- $bigfont->width() * length($self->get_caption())/2,
1155                      $self->get_vertical_offset()-$bigfont->height()-$self->{curved_height}/2,
1156                      $self->get_caption(), $outline_color );
1157
1158 }
1159
1160 1;