File Coverage

blib/lib/PGPLOT/Simple.pm

Criterion	Covered	Total	%
statement	13	15	86.6
branch			n/a
condition			n/a
subroutine	5	5	100.0
pod			n/a
total	18	20	90.0

package PGPLOT::Simple;

use 5.008000;
use strict;
use warnings;

use Exporter qw/import/;

use PGPLOT;
use Carp qw/croak/;
use List::Util qw/min max/;
use List::MoreUtils qw/any none/;
use Scalar::Util qw/looks_like_number/;

our %EXPORT_TAGS = (
    'essential' => [qw(
        set_begin           set_end         set_environment
        set_viewport        set_window      set_box
        set_active_panel    set_range

        write_label         write_text      write_text_viewport

        draw_points         draw_line       draw_polyline
        draw_polygon        draw_rectangle  draw_circle
        draw_arrow          draw_error_bars draw_function
        draw_histogram

        move_pen
    )],
    'optional'  =>  [qw(
        set_color               set_color_representation    set_line_width
        set_line_style          set_character_height        set_font
        set_text_background     set_fill_area_style         set_hatching_style
        set_arrow_style

    )],
    'pgplot'    =>  [ @PGPLOT::EXPORT ],
);

our @EXPORT_OK = ();
our @EXPORT = ();

Exporter::export_ok_tags('essential');
Exporter::export_ok_tags('optional');
Exporter::export_ok_tags('pgplot');

our $VERSION = '0.05';


my $ATTR2SUB = {
    font            => \&set_font,
    color           => \&set_color,
    width           => \&set_line_width,
    style           => \&set_line_style,
    fill            => \&set_fill_area_style,
    height          => \&set_character_height,
    background      => \&set_text_background,
    arrow_style     => \&set_arrow_style,
    hatching_style  => \&set_hatching_style,
};

my $PALLETE = {
    Background      =>  0,
    Foreground      =>  1,
    Red             =>  2,
    Green           =>  3,
    Blue            =>  4,
    Cyan            =>  5,
    Magenta         =>  6,
    Yellow          =>  7,
    Orange          =>  8,
    GreenYellow     =>  9,
    GreenCyan       => 10,
    BlueCyan        => 11,
    BlueMagenta     => 12,
    RedMagenta      => 13,
    DarkGray        => 14,
    LightGray       => 15,
};

my $FONT = {
    Normal          => 1,
    Roman           => 2,
    Italic          => 3,
    Script          => 4,
};

my $LINE_STYLE = {
    FullLine        => 1,
    Dashed          => 2,
    DotDashDotDash  => 3,
    Dotted          => 4,
    DashDotDotDot   => 5,
};

my $TEXT_ALIGN = {
    Left            => 0.0,
    Center          => 0.5,
    Right           => 1.0,
};

my $FILL_AREA_STYLE = {
    Solid           => 1,
    Outline         => 2,
    Hatched         => 3,
    CrossHatched    => 4,
};

my $BOX_STYLE = {
    Clean            => -2,
    Box              => -1,
    BoxCoord         =>  0,
    BoxCoordAxes     =>  1,
    BoxCoordAxesGrid =>  2,
    BoxXLog          => 10,
    BoxYLog          => 20,
    BoxXYLog         => 30,
};

my $ARROW_STYLE = {
    Filled           => 1,
    Outline          => 2,
};


###############################################################
# OPEN, CLOSING, AND SELECTING DEVICES
###############################################################


# Open a graphics device
sub set_begin {
    my $args = shift;

    my $file  = exists $args->{'file'} ? $args->{'file'} : "-/CPS";
    # The device specification for the plot device
    my $nxsub = exists $args->{'num_x_sub'} ? $args->{'num_x_sub'} : 1;
    my $nysub = exists $args->{'num_y_sub'} ? $args->{'num_y_sub'} : 1;
    # Number of X and Y subdivisions of the view surface
    my $unit  = 0;   # This is ignored by the library

    my $status = pgbeg( $unit, $file, $nxsub, $nysub );

    return $status;
}

# Closes all graphics devices
sub set_end {
    pgend;
    return;
}

sub set_environment {
    my $args = shift;

    croak "x_min, x_max, y_min, y_max parameters are required."
        if any {! exists $args->{$_} } qw/x_min x_max y_min y_max/;

    my $x_min = $args->{'x_min'};
    my $x_max = $args->{'x_max'};

    my $y_min = $args->{'y_min'};
    my $y_max = $args->{'y_max'};

    my $justify = 0;
    # Default don't justify the axes together
    if ( exists $args->{'justify'}  &&  $args->{'justify'} ne 0 ) {
        $justify = 1;
    }

    my $axes = $BOX_STYLE->{'BoxCoordAxes'};
    # Default draw box and label it with coordinates and draw the coordinate axes
    if ( exists $args->{'axes'} ) {
        my $id = $args->{'axes'};

        if ( exists $BOX_STYLE->{ $id } ) {
            $axes = $BOX_STYLE->{ $id };
            # If the user provided a valid axes key
        }
        elsif ( looks_like_number $id  &&  any { $id == $_ } (-2,-1,0,1,2,10,20,30) ) {
            $axes = $id;
            # If the user provided directly the axes code
        }
        else {
            croak "Wrong axes parameter supplied.";
        }
    }

    pgsave; # Save current attributes

    set_attributes( $args );    # Design settings

    pgenv( $x_min, $x_max, $y_min, $y_max, $justify, $axes );

    pgunsa; # Restore previous attributes

    return;
}


###############################################################
# WINDOWS AND VIEWPORTS
###############################################################


# Set viewport
sub set_viewport {
    my $args = shift;

    croak "x_left, x_right, y_bot, y_top parameters are required."
        if any {! exists $args->{$_} } qw/x_left x_right y_bot y_top/;

    croak "Must provide a value between 0 and 1."
        if any { !(
                    looks_like_number $args->{$_}
                    && $args->{$_} >= 0
                    && $args->{$_} <= 1
                  )
               } qw/x_left x_right y_bot y_top/;

    my $x_left = $args->{'x_left'};
    my $x_right = $args->{'x_right'};

    my $y_bot = $args->{'y_bot'};
    my $y_top = $args->{'y_top'};

    pgsvp( $x_left, $x_right, $y_bot, $y_top );

    return;
}

# Set window
sub set_window {
    my $args = shift;

    croak "x_min, x_max, y_min, y_max parameters are required."
        if any {! exists $args->{$_} } qw/x_min x_max y_min y_max/;

    my $x_min = $args->{'x_min'};
    my $x_max = $args->{'x_max'};

    my $y_min = $args->{'y_min'};
    my $y_max = $args->{'y_max'};

    pgswin( $x_min, $x_max, $y_min, $y_max );

    return;
}

# Switch to a different panel on the view surface
sub set_active_panel {
    my $args = shift;

    croak "x_index and y_index parameters are required."
        if any {! exists $args->{$_} } qw/x_index y_index/;

    my $ix = $args->{'x_index'};
    my $iy = $args->{'y_index'};

    pgpanl( $ix, $iy );

    return;
}

# Choose axis limits
sub set_range {
    my $args = shift;

    croak "x1, x2, x_low and x_high parameters are required."
        if any{! exists $args->{$_} } qw/x1 x2 x_low x_high/;

    my $x1   = $args->{'x1'};
    my $x2   = $args->{'x2'};

    my $x_lo = $args->{'x_low' };
    my $x_hi = $args->{'x_high'};

    pgrnge($x1, $x2, $x_lo, $x_hi );

    return;
}


###############################################################
# AXES, BOXES AND LABELS
###############################################################


# Draw frame and write (DD) HH MM SS.S labelling
sub set_box {
    my $args = shift;

    my $x_opt   = exists $args->{'x_style'} ? $args->{'x_style'} : 'ABCGZHON';
    my $y_opt   = exists $args->{'y_style'} ? $args->{'y_style'} : 'ABCGN';

    my $x_tick  = exists $args->{'x_tick'}  ? $args->{'x_tick'}  : 0.0;
    my $y_tick  = exists $args->{'y_tick'}  ? $args->{'y_tick'}  : 0.0;

    my $n_x_sub = exists $args->{'n_x_sub'} ? $args->{'n_x_sub'} : 0;
    my $n_y_sub = exists $args->{'n_y_sub'} ? $args->{'n_y_sub'} : 0;

    pgsave; # Save current attributes

    set_attributes( $args );    # Design settings

    pgtbox( $x_opt, $x_tick, $n_x_sub, $y_opt, $y_tick, $n_y_sub );

    pgunsa; # Restore previous attributes

    return;
}

# Write labels for x-axis, y-axis, and top of plot
sub write_label {
    my $args = shift;

    my $x     = exists $args->{'x'}     ? $args->{'x'}     : 'X';
    my $y     = exists $args->{'y'}     ? $args->{'y'}     : 'Y';
    my $title = exists $args->{'title'} ? $args->{'title'} : 'Untitled';

    pgsave; # Save current attributes

    set_attributes( $args );    # Design settings

    pglab( $x, $y, $title );

    pgunsa; # Restore previous attributes

    return;
}

sub write_text_viewport {
    my $args = shift;

    croak "Must provide a string to write."
        unless exists $args->{'string'};

    my $text = $args->{'string'};
    my $side  = exists $args->{'side'}     ? $args->{'side'}     : 'BR';
    # Default to bottom right positioned
    my $disp  = exists $args->{'displace'} ? $args->{'displace'} :    1;
    # Default displacement relative to the viewport
    my $coord = exists $args->{'coord'}    ? $args->{'coord'}    :    1;
    # Default location of the character string along the specified edge of the viewport
    my $fjust = get_align( $args->{'justify'} );

    pgsave; # Save current attributes

    set_attributes( $args );    # Design settings

    pgmtxt( $side, $disp, $coord, $fjust, $text );

    pgunsa; # Restore previous attributes

    return;
}


###############################################################
# PRIMITIVES
###############################################################


# LINES
#

# Draw a polyline (curve defined by line-segments)
sub draw_polyline {
    my $args = shift;

    croak "x and y parameters are required."
        if any {! exists $args->{$_} } qw/x y/;

    my $x = $args->{'x'};
    my $y = $args->{'y'};

    pgsave; # Save current attributes

    set_attributes( $args );    # Design settings

    # Line size
    my $size = scalar @$x;

    pgline( $size, $x, $y );

    pgunsa; # Restore previous attributes

    return;
}

# Move pen (change current pen position)
sub move_pen {
    my $args = shift;

    my ($x, $y) = ();

    if ( exists $args->{'x'}  &&  exists $args->{'y'} ) {
        $x = $args->{'x'};
        $y = $args->{'y'};

        pgmove( $x, $y );   # Move pen to position
    }

    pgqpos( $x, $y );   # Return current pen position

    return ($x, $y);
}

# Draw a line from the current pen position to a point
sub draw_line {
    my $args = shift;

    croak "x and y parameters are required."
        if any {! exists $args->{$_} } qw/x y/;

    my $x = $args->{'x'};
    my $y = $args->{'y'};

    pgsave; # Save current attributes

    set_attributes( $args );    # Design settings

    pgdraw( $x, $y );

    pgunsa; # Restore previous attributes

    return;
}

# POLYGONS AND FILLED AREAS
#

# Draw a polygon, using fill-area attributes
sub draw_polygon {
    my $args = shift;

    croak "x and y parameters are required."
        if any {! exists $args->{$_} } qw/x y/;

    my $x = $args->{'x'};
    my $y = $args->{'y'};

    pgsave; # Save current attributes

    set_attributes( $args );    # Design settings

    # Number of points
    my $num = scalar @$x;

    pgpoly( $num, $x, $y );

    pgunsa; # Restore previous attributes

    return;
}

# Draw a circle, using fill-area attributes
sub draw_circle {
    my $args = shift;

    croak "x, y and radius parameters are required."
        if any {! exists $args->{$_} } qw/x y radius/;

    my $x = $args->{'x'};
    my $y = $args->{'y'};
    my $radius = $args->{'radius'};

    pgsave; # Save current attributes

    set_attributes( $args );    # Design settings

    pgcirc( $x, $y, $radius );

    pgunsa; # Restore previous attributes

    return;
}

# Draw a rectangle, using fill-area attibutes
sub draw_rectangle {
    my $args = shift;

    croak "x1,y1,x2 and y2 parameters are required."
        if any {! exists $args->{$_} } qw/x1 x2 y1 y2/;

    my $x1 = $args->{'x1'};
    my $x2 = $args->{'x2'};
    my $y1 = $args->{'y1'};
    my $y2 = $args->{'y2'};

    pgsave; # Save current attributes

    set_attributes( $args );    # Design settings

    pgrect( $x1, $x2, $y1, $y2 );

    pgunsa; # Restore previous attributes

    return;
}


# GRAPH MARKERS
#

# Draw several graph markers.
sub draw_points {
    my $args = shift;

    croak "x, and y parameters are required."
        if any {! exists $args->{$_} } qw/x y/;

    my $x = $args->{'x'};
    my $y = $args->{'y'};
    my $symbol = exists $args->{'symbol'} ? $args->{'symbol'} : -1;

    pgsave; # Save current attributes

    set_attributes( $args );    # Design settings

    # How many
    my $num = scalar @$x;

    pgpt( $num, $x, $y, $symbol );

    pgunsa; # Restore previous attributes

    return;
}


# TEXT
#

# Write text at arbitrary position and angle
sub write_text {
    my $args = shift;

    croak "x,y and string parameters are required."
        if any {! exists $args->{$_} } qw/x y string/;

    my $x = $args->{'x'};
    my $y = $args->{'y'};
    my $string = $args->{'string'};

    my $align = get_align( $args->{'align'} );
    my $angle = get_angle( $args->{'angle'} );

    pgsave; # Save current attributes

    set_attributes( $args );    # Design settings

    pgptxt( $x, $y, $angle, $align, $string );

    pgunsa; # Restore previous attributes

    return;
}


# ARROWS
#

sub draw_arrow {
    my $args = shift;

    croak "x1,y1,x2 and y2 parameters are required."
        if any {! exists $args->{$_} } qw/x1 x2 y1 y2/;

    my $x1 = $args->{'x1'};
    my $x2 = $args->{'x2'};
    my $y1 = $args->{'y1'};
    my $y2 = $args->{'y2'};

    pgsave; # Save current attributes

    set_attributes( $args );    # Design settings

    pgarro( $x1, $y1, $x2, $y2 );

    pgunsa; # Restore previous attributes

    return;
}


###############################################################
# ATTRIBUTES
###############################################################


sub set_attributes {
    my $args = shift;

    for my $attr ( keys %$ATTR2SUB ) {
        if ( exists $args->{ $attr } ) {
             &{ $ATTR2SUB->{ $attr } }( $args->{ $attr } );
        }
    }

    return;
}


# COLOR
#

sub set_color {
    my $id = shift;

    my $color = $PALLETE->{'Foreground'}; # Default color

    if (defined $id) {
        if ( exists $PALLETE->{ $id } ) {
            $color = $PALLETE->{ $id };
            # If the user provided a valid color key
        }
        elsif ( looks_like_number $id  &&  $id >= 0  &&  $id <= 255 ) {
            $color = $id;
            # If the user provided directly the color code
        }
        else {
            croak "Must provide a valid color.";
        }
    }

    pgsci( $color ); # PGPLOT call setting color

    return;
}

sub set_color_representation {
    my $args = shift;

    croak "code, red, green and blue parameters are required."
        if any { !(
                    looks_like_number $args->{$_}
                    &&  exists $args->{$_}
                  )
               } qw/code red green blue/;

    my $code = $args->{'code'};
    my $red = $args->{'red'};
    my $green = $args->{'green'};
    my $blue = $args->{'blue'};

    # Data range validation
    croak "Code index value out of range"
        unless ( $code >= 0  &&  $code <= 255 );

    croak "Any of the rgb values supplied is out of range."
        if any { !( $_ >= 0  &&  $_ <= 1 ) }
            ($red, $green, $blue);

    pgscr( $code, $red, $green, $blue );

    return;
}


# LINE ATTRIBUTES
#

sub set_line_width {
    my $num = shift;

    my $width = 2;  # Default width

    if ( defined $num ) {
        if ( looks_like_number $num  &&  $num >= 1  &&  $num <= 201 ) {
            $width = $num;
        }
        else {
            croak "Must provide a valid integer number for line width.";
        }
    }

    pgslw( $width );   # PGPLOT call setting line width

    return;
}

sub set_line_style {
    my $id = shift;

    my $style = $LINE_STYLE->{'Solid'}; # Default style

    if (defined $id) {
        if ( exists $LINE_STYLE->{ $id } ) {
            $style = $LINE_STYLE->{ $id };
            # If the user provided a valid line style
        }
        elsif ( looks_like_number $id  &&  $id >= 1  &&  $id <= 5 ) {
            $style = $id;
            # If the user provided directly the style code
        }
        else {
            croak "Must provide a valid style.";
        }
    }

    pgsls( $style ); # PGPLOT call setting line style

    return;
}


# TEXT AND MARKER ATTRIBUTES
#

sub set_character_height {
    my $value = shift;

    my $height = 1.0;    # Default height

    if (defined $value) {
        if ( looks_like_number $value ) {
            $height = $value;
        }
        else {
            croak "Must provide a real number for character height.";
        }
    }

    pgsch( $height );   # PGPLOT call setting line height

    return;
}

sub set_font {
    my $id = shift;

    my $font = $FONT->{'Normal'};   # Default font

    if (defined $id) {
        if ( exists $FONT->{ $id } ) {
            $font = $FONT->{ $id };
            # If the user provided a valid font type
        }
        elsif ( looks_like_number $id  &&  $id >= 1  &&  $id <= 4 ) {
            $font = $id;
            # If the user provided directly the font type
        }
        else {
            croak "Must provide a valid font.";
        }
    }

    pgscf( $font );     # PGPLOT call setting font type

    return;
}

sub set_text_background {
    my $id = shift;

    my $color = -1; # Default transparent color

    if (defined $id) {
        if ( exists $PALLETE->{ $id } ) {
            $color = $PALLETE->{ $id };
            # If the user provided a valid color key
        }
        elsif ( looks_like_number $id  &&  $id >= -1  &&  $id <= 255 ) {
            $color = $id;
            # If the user provided directly the color code
        }
        else {
            croak "Must provide a valid color.";
        }
    }

    pgstbg( $color ); # PGPLOT call setting text background color

    return;
}


# FILL-AREA ATTRIBUTES
#

sub set_fill_area_style {
    my $id = shift;

    my $style = $FILL_AREA_STYLE->{'Solid'};  # Default text alignment

    if (defined $id) {
        if ( exists $FILL_AREA_STYLE->{ $id } ) {
            $style = $FILL_AREA_STYLE->{ $id };
            # If the user provided a valid fill style
        }
        elsif ( looks_like_number $id  &&  $id >= 1  &&  $id <= 4 ) {
            $style = $id;
            # If the user provided directly the fill style
        }
        else {
            croak "Must provide a valid fill style.";
        }
    }

    pgsfs( $style );

    return;
}

sub set_hatching_style {
    my $args = shift;

    my $angle = 45.0;
    my $sepn  =  1.0;
    my $phase  =  0.0;
    # Default values

    if ( exists $args->{'angle'} ) {
        my $value = $args->{'angle'};
        if ( looks_like_number $value  &&  $value >= 0  &&  $value <= 360 ) {
            $angle = $value;
        }
        else {
            croak "Must provide a valid angle value.";
        }
    }
    if ( exists $args->{'spacing'} ) {
        my $value = $args->{'spacing'};
        if ( looks_like_number $value  &&  $value >= 0  &&  $value <= 100 ) {
            $sepn = $value;
        }
        else {
            croak "Must provide a valid spacing value.";
        }
    }
    if ( exists $args->{'phase'} ) {
        my $value = $args->{'phase'};
        if ( looks_like_number $value  &&  $value >= 0  &&  $value <= 1 ) {
            $phase = $value;
        }
        else {
            croak "Must provide a valid phase value.";
        }
    }

    pgshs( $angle, $sepn, $phase );

    return;
}


# ARROW ATTRIBUTES
#

sub set_arrow_style {
    my $args = shift;

    my $fs    = $ARROW_STYLE->{'Filled'};
    my $angle =  45;
    my $barb  = 0.3;

    if( exists $args->{'fill'} ) {
        my $id = $args->{'fill'};
        if( exists $ARROW_STYLE->{ $id } ) {
            $fs = $ARROW_STYLE->{ $id };
            # If the user provided a valid fill style
        }
        elsif ( looks_like_number $id  &&  $id >= 1  &&  $id <= 2 ) {
            $fs = $id;
            # If the user provided directly the fill style
        }
        else {
            croak "Must provide a valid fill style.";
        }
    }
    if( exists $args->{'arrow_angle'} ) {
        my $value = $args->{'arrow_angle'};
        if ( looks_like_number $value  &&  $value >= 0  &&  $value <= 360 ) {
            my $angle = $value;
        }
        else {
            croak "Must provide a valid arrow angle";
        }
    }
    if( exists $args->{'arrow_barb'} ) {
        my $value = $args->{'arrow_barb'};
        if ( looks_like_number $value  &&  $value >= 0  &&  $value <= 1 ) {
            my $angle = $value;
        }
        else {
            croak "Must provide a valid arrow barb";
        }
    }

    pgsah( $fs, $angle, $barb );

    return;
}


###############################################################
# XY PLOTS
###############################################################


# ERROR BARS
#

# Horizontal / Vertical error bars
sub draw_error_bars {
    my $args = shift;

    croak "Must provide either (x1,x2,y) or (y1,y2,x) parameters."
        if none { exists $args->{$_} } qw/x y/;

    # Error bars terminal, undef mean proportional of the length of the bar

    pgsave; # Save current attributes

    set_attributes( $args );    # Design settings

    if( exists $args->{'y'} ) {
        croak "x1, x2 and y parameters are required."
            if any {! exists $args->{$_} } qw/x1 x2 y terminal/;

        my $x1 = $args->{'x1'};
        my $x2 = $args->{'x2'};
        my $y  = $args->{'y'};
        my $terminals = $args->{'terminal'};
        my $num = scalar @$y;

        pgerrx( $num, $x1, $x2, $y, $terminals );
    }
    elsif ( exists $args->{'x'} ) {
        croak "y1, y2, and x parameters are required."
            if any {! exists $args->{$_} } qw/y1 y2 x terminal/;

        my $y1 = $args->{'y1'};
        my $y2 = $args->{'y2'};
        my $x  = $args->{'x'};
        my $terminals = $args->{'terminal'};
        my $num = scalar @$x;

        pgerry( $num, $x, $y1, $y2, $terminals );
    }

    pgunsa; # Restore previous attributes

    return;
}


# CURVES DEFINED BY FUNCTIONS
#

sub draw_function {
    my ($by, $args) = @_;

    croak "Must define by x, y or xy."
        if none { $by eq $_ } qw/x y xy/;

    my $flag = exists $args->{'flag'} ? $args->{'flag'} : 1;
    # Default plotted in the current window and viewport

    pgsave; # Save current attributes

    set_attributes( $args );    # Design settings

    if ($by eq 'x') {       # Function defined by X = F(Y)
        croak "fy, num, min and max parameters are required."
            if any {! exists $args->{$_} } qw/fy num min max/;

        my $fy   = $args->{'fy'};
        my $num  = $args->{'num'};
        my $min  = $args->{'min'};
        my $max  = $args->{'max'};

        pgfunx( $fy, $num, $min, $max, $flag );
    }
    elsif ($by eq 'y') {    # Function defined by Y = F(X)
        croak "fx, num, min and max parameters are required."
            if any {! exists $args->{$_} } qw/fx num min max/;

        my $fx   = $args->{'fx'};
        my $num  = $args->{'num'};
        my $min  = $args->{'min'};
        my $max  = $args->{'max'};

        pgfuny( $fx, $num, $min, $max, $flag );
    }
    else {   # Function defined by X = F(T), Y = G(T)
        croak "fx, fy, num, min and max parameters are required."
            if any {! exists $args->{$_} } qw/fx fy num min max/;

        my $fx   = $args->{'fx'};
        my $fy   = $args->{'fy'};
        my $num  = $args->{'num'};
        my $min  = $args->{'min'};
        my $max  = $args->{'max'};

        pgfunt( $fx, $fy, $num, $min, $max, $flag );
    }

    pgunsa; # Restore previous attributes

    return;
}


# HISTOGRAMS
#

sub draw_histogram {
    my $args = shift;

    croak "data parameter is required."
        unless exists $args->{'data'};

    pgsave; # Save current attributes

    set_attributes( $args );    # Design settings

    my $data = $args->{'data'};
    my $flag = exists $args->{'flag'} ? $args->{'flag'} : 1;
    # Default plotted in the current window and viewport
    my @temp = grep { defined } @$data;
    # This if done because List::Util's die with arrays that may contain undef
    my $min  = exists $args->{'min'}  ? $args->{'min'}  : min @temp;
    my $max  = exists $args->{'max'}  ? $args->{'max'}  : max @temp;
    my $num  = scalar @$data;
    my $nbin = exists $args->{'nbin'} ? $args->{'nbin'} : $num % 400;

    pghist( $num, $data, $min, $max, $nbin, $flag );

    pgunsa; # Restore previous attributes

    return;
}


###############################################################
# MISC
###############################################################


sub get_align {
    my $id = shift;

    my $align = $TEXT_ALIGN->{'Left'};  # Default text alignment

    if (defined $id) {
        if ( exists $TEXT_ALIGN->{ $id } ) {
            $align = $TEXT_ALIGN->{ $id };
            # If the user provided a valid text alignment
        }
        elsif ( looks_like_number $id  &&  any { $id == $_ } (0, 0.5, 1) ) {
            $align = $id;
            # If the user provided directly the text alignment
        }
        else {
            croak "Must provide a valid align or justification value.";
        }
    }

    return $align;
}

sub get_angle {
    my $degree = shift;

    my $angle = 0;  # Default angle

    if (defined $degree) {
        if ( looks_like_number $degree  &&  $degree >= 0  &&  $degree <= 360 ) {
            $angle = $degree;
            # If the user provided a valid degree
        }
        else {
            croak "Must provide a valid angle degree value.";
        }
    }

    return $angle;
}


1;

__END__