view release on metacpan or  search on metacpan

lib/Chart/GGPlot/Scale/Continuous.pm  view on Meta::CPAN

    my $pal    = $self->palette->($uniq);
    my $scaled = $pal->slice( match( $new_p, $uniq ) );

    return $scaled->setbadtoval( $self->na_value );
}

method dimension ( $expand = pdl([0, 0, 0, 0]) ) {
    return expand_range4( $self->get_limits(), $expand );
}

# return arrayref of breaks
method get_breaks ( $limits=$self->get_limits ) {
    if ( $limits->isempty ) {
        $limits = $self->get_limits();
    }

    return pdl( [] ) if $self->isempty;
    return null if ( $self->breaks->$_call_if_object('isempty') );

    # Limits in transformed space need to be converted back to data space
    $limits = $self->trans->inverse->($limits);

    my $breaks;
    if ( zero_range($limits) ) {
        $breaks = pdl( [ $limits->at(0) ] );
    }
    elsif ( not defined $self->breaks ) {
        $breaks = $self->trans->breaks->($limits);
    }
    else {
        $breaks = call_if_coderef( $self->breaks, $limits );
    }

    # Breaks in data space need to be converted back to transformed space
    # And any breaks outside the dimensions need to be flagged as missing

    $breaks = censor( $self->trans->transform->($breaks),
        $self->trans->transform->($limits), 0 );
    return $breaks;
}

method get_breaks_minor (
    $n      = 2,
    $b      = $self->break_positions,
    $limits = $self->get_limits()
  ) {
    if ( $limits->isempty ) {
        $limits = $self->get_limits();
    }

    return pdl( [] ) if ( zero_range($limits) );
    return null if ( $self->minor_breaks->$_call_if_object('isempty') );

    my $breaks;
    if ( not defined $self->minor_breaks ) {
        $breaks =
          $b->isempty
          ? null
          : $self->trans->minor_breaks->( $b, $limits, $n );
    }
    elsif ( Ref::Util::is_coderef( $self->minor_breaks ) ) {

        # Find breaks in data space, and convert to numeric
        $breaks = $self->minor_breaks->( $self->trans->inverse->($limits) );
        $breaks = $self->trans->transform->($breaks);
    }
    else {
        $breaks = $self->trans->transform->( $self->minor_breaks );
    }

    # Any minor breaks outside the dimensions need to be thrown away
    return discard( $breaks, $limits );
}

method get_labels ( $breaks = $self->get_breaks ) {
    return null if ( $breaks->isempty );

    $breaks = $self->trans->inverse->($breaks);

    my $labels;
    if ( not defined $self->labels ) {
        $labels = $self->trans->format->($breaks);
    }
    elsif ( $self->labels->$_call_if_object('isempty') ) {
        return PDL::SV->new( [] );
    }
    else {
        $labels = call_if_coderef( $self->labels, $breaks );
    }
    if ( $labels->length != $breaks->length ) {
        die("Breaks and labels are different lengths");
    }
    return $labels;
}

method break_info ($range=$self->dimension) {
    if ( $range->$_DOES('Chart::GGPlot::Range') ) {
        $range = $range->range;
    }
    if ( $range->isempty ) {
        $range = $self->dimension;
    }

    # major breaks and labels
    my $major  = $self->get_breaks($range);
    my $labels = $self->get_labels($major);

    # drop oob breaks/labels by testing major == NA
    if ( not $labels->isempty and $major->badflag ) {
        $labels = $labels->where( $major->isgood );
    }
    if ( not $major->isempty and $major->badflag ) {
        $major = $major->where( $major->isgood );
    }

    my $minor = $self->get_breaks_minor( 2, $major, $range );
    unless ( $minor->isempty and $minor->badflag ) {
        $minor = $minor->where( $minor->isgood );
    }

    # rescale to [0, 1]