File Coverage

blib/lib/Geo/WeatherNWS.pm

Criterion	Covered	Total	%
statement	344	466	73.8
branch	119	190	62.6
condition	74	125	59.2
subroutine	20	28	71.4
pod	20	20	100.0
total	577	829	69.6

package Geo::WeatherNWS;

#------------------------------------------------------------------------------
#
# Package Name:  Get Observations from NWS (Geo::WeatherNWS)
#
# Last Modified:  18 December 2001 - Prepared for CPAN - Marc Slagle
#                 24 February 2002 - Adding server/error code - Marc
#                 10 August 2011   - changed FTP server name, added tests,
#                                    docs, some restructuring. - Bob Ernst
#                 14 November 2012 - removed unneeded /d after tr,
#                                    make network tests optional,
#                                    check status of opens - Bob
#                 26 November 2012 - Address bug 14632 (METAR Decoding) from dstroma
#                                    Address bug 27513 (Geo-WeatherNWS returns wrong station code)
#                                    from Guenter Knauf
#                                    Fix issues with undefined values,
#                                    Change some conversion constants,
#                                    Round instead of truncate results,
#                                    Only calculate windchill for proper range,
#                                    "ptemerature" is now spelled "ptemperature"
#                                    Fixed handling of condition text
#                                    Relax ICAO naming rules
#                                    Change ICAO website
#                                    Change http web site from weather.noaa.gov
#                                    to www.aviationweather.gov, and change parsing to match.
#                                    Add report_date and report_time items.
#                                    - Bob
#                 27 November 2012 - Add POD documentation for new functions.
#                 1 January 2017 - Switched from POSIX module to File::Temp
#                 23 February 2026 - changed to use updated http web site,
#                                    limit heat index calculation range,
#                                    use blanks instead of undef values,
#                                    remove leading zero from Celsius
#                                    Reformat using perltidy
#
#
#------------------------------------------------------------------------------

#------------------------------------------------------------------------------
# We need these
#------------------------------------------------------------------------------

require 5.005_62;
use strict;
use warnings;
use Carp;
use File::Temp;
use HTTP::Request;
use IO::Handle;
use LWP::UserAgent;
use Net::FTP;

#------------------------------------------------------------------------------
# Version
#------------------------------------------------------------------------------

our $VERSION = '1.06';

#------------------------------------------------------------------------------
# Round function
# Using Math::Round would add another dependency
#------------------------------------------------------------------------------

sub round {
    my $float   = shift;
    my $rounded = "";

    if ( defined $float && $float ne "" ) {
        $rounded = sprintf "%.0f", $float;
    }
    return $rounded;
}

#------------------------------------------------------------------------------
# Temperature conversion
# If the temperature we are converting from is undefined,
# then the temperature we are converting to is also undefined.
#------------------------------------------------------------------------------

sub convert_f_to_c {
    my $fahrenheit = shift;
    my $celsius    = "";

    if ( defined $fahrenheit && $fahrenheit ne "" ) {
        $celsius = ( 5.0 / 9.0 ) * ( $fahrenheit - 32.0 );
    }
    return $celsius;
}

sub convert_c_to_f {
    my $celsius    = shift;
    my $fahrenheit = "";

    if ( defined $celsius && $celsius ne "" ) {
        $fahrenheit = ( ( 9.0 / 5.0 ) * $celsius ) + 32.0;
    }
    return $fahrenheit;
}

#------------------------------------------------------------------------------
# Windchill
#------------------------------------------------------------------------------

sub windchill {
    my $F              = shift;
    my $wind_speed_mph = shift;
    my $windchill      = "";

    # This is the North American wind chill index.
    # Windchill temperature is only defined for:
    # *  temperatures at or below 50 F
    # *  wind speed above 3 mph
    # Bright sunshine may increase the wind chill temperature by
    # 10 to 18 degress F.

    if (   defined $F
        && defined $wind_speed_mph
        && $F ne ""
        && $wind_speed_mph ne "" )
    {
   # Old Formula
   # my $Windc=int(
   #    0.0817*
   #    (3.71*$Self->{windspeedmph}**0.5 + 5.81 - 0.25*$Self->{windspeedmph})*
   #    ($F - 91.4) + 91.4);

        # New Formula
        if ( $F <= 50 && $wind_speed_mph > 3 ) {
            $windchill
                = 35.74 + ( 0.6215 * $F )
                - ( 35.75 * ( $wind_speed_mph**0.16 ) )
                + ( ( 0.4275 * $F ) * ( $wind_speed_mph**0.16 ) );
        }
    }
    return $windchill;
}

#------------------------------------------------------------------------------
# Heat Index
#------------------------------------------------------------------------------

sub heat_index {
    my $F          = shift;
    my $rh         = shift;
    my $heat_index = "";

    if (   defined $F
        && $F ne ""
        && $F >= 80
        && defined $rh
        && $rh ne "" )
    {
        $heat_index
            = -42.379 + 2.04901523 * $F
            + 10.14333127 * $rh
            - 0.22475541 * $F * $rh
            - 6.83783e-03 * $F**2
            - 5.481717e-02 * $rh**2
            + 1.22874e-03 * $F**2 * $rh
            + 8.5282e-04 * $F * $rh**2
            - 1.99e-06 * $F**2 * $rh**2;
    }
    return $heat_index;
}

#------------------------------------------------------------------------------
# Convert wind speed from nautical miles per hour to miles per hour
#------------------------------------------------------------------------------

sub convert_kts_to_mph {
    my $knots = shift;
    my $mph   = "";

    if ( defined $knots && $knots ne "" ) {
        $mph = $knots * 1.150779;
    }
    return $mph;
}

#------------------------------------------------------------------------------
# Convert wind speed from nautical miles per hour to kilometers per hour
#------------------------------------------------------------------------------

sub convert_kts_to_kmh {
    my $knots = shift;
    my $kmh   = "";

    if ( defined $knots && $knots ne "" ) {
        $kmh = $knots * 1.852;
    }
    return $kmh;
}

#------------------------------------------------------------------------------
# Convert miles to kilometers
#------------------------------------------------------------------------------

sub convert_miles_to_km {
    my $miles = shift;
    my $km    = "";

    if ( defined $miles && $miles ne "" ) {
        $km = $miles * 1.609344;
    }
    return $km;
}

#------------------------------------------------------------------------------
# Translate Weather into readable Conditions Text
#
# Reference is WMO Code Table 4678
#------------------------------------------------------------------------------

sub translate_weather {
    my $coded              = shift;
    my $old_conditionstext = shift;
    my $old_conditions1    = shift;
    my $old_conditions2    = shift;
    my ( $conditionstext, $conditions1, $conditions2, $intensity );

    # We use %Converter to translate 2-letter codes into text

    my %Converter = (
        BR => 'Mist',
        TS => 'Thunderstorm',
        MI => 'Shallow',
        PR => 'Partial',
        BC => 'Patches',
        DR => 'Low Drifting',
        BL => 'Blowing',
        SH => 'Shower',
        FZ => 'Freezing',
        DZ => 'Drizzle',
        RA => 'Rain',
        SN => 'Snow',
        SG => 'Snow Grains',
        IC => 'Ice Crystals',
        PE => 'Ice Pellets',
        PL => 'Ice Pellets',
        GR => 'Hail',
        GS => 'Small Hail/Snow',
        UP => 'Unknown Precipitation',
        FG => 'Fog',
        FU => 'Smoke',
        VA => 'Volcanic Ash',
        DU => 'Widespread Dust',
        SA => 'Sand',
        HZ => 'Haze',
        PY => 'Spray',
        PO => 'Dust Devils',
        SQ => 'Squalls',
        FC => 'Tornado',
        SS => 'Sandstorm'
    );

    my $Block1 = "";
    my $Block2 = "";
    if ( $coded =~ /^[-+]/ ) {

        # Heavy(+) or Light(-) condition

        if ( !$old_conditions1 ) {
            my $Modifier = substr( $coded, 0, 1 );    # +/-
            my $Block1t  = substr( $coded, 1, 2 );    # e.g. TS
            my $Block2t  = substr( $coded, 3, 4 );    # e.g. RA

            if ( defined( $Converter{$Block1t} ) ) {
                $Block1 = $Converter{$Block1t};       # e.g. Thunderstorm
            }
            else {
                $Block1 = "";
            }
            $conditions1 = $Block1;                   # e.g. Thunderstorm

            if ($Block2t) {
                if ( defined( $Converter{$Block2t} ) ) {
                    $Block2 = $Converter{$Block2t};    # e.g. Rain
                }
                else {
                    $Block2 = "";
                }
                $conditions2 = $Block2;                # e.g. Rain
            }

            if ( $Modifier =~ /^\-/ ) {
                $Block1    = "Light $Block1";    # e.g. Light Thunderstorm
                $intensity = "Light";
            }
            elsif ( $Modifier =~ /^\+/ ) {
                $Block1    = "Heavy $Block1";    # e.g. Heavy Thunderstorm
                $intensity = "Heavy";
            }

            if ($Block2) {
                $Block1 = "$Block1 $Block2";    # e.g. Light Thunderstorm Rain
            }

            if ($old_conditionstext) {
                if ( $Block1 eq "SH" ) {
                    $conditionstext = "$Block2 of $Block1";
                    $conditions1    = "Showers of";
                }
                else {
                    $conditionstext = "$old_conditionstext and $Block1";
                }
            }
            else {
                $conditionstext = $Block1;
            }
        }
    }
    else {
        # Moderate condition

        my $Block1 = "";
        my $Block2 = "";
        if ( !$old_conditions1 ) {
            my $Block1t = substr( $coded, 0, 2 );    # e.g. TS
            my $Block2t = substr( $coded, 2, 4 );    # e.g. RA

            if ( defined( $Converter{$Block1t} ) ) {
                $Block1 = $Converter{$Block1t};      # e.g. Thunderstorm
            }
            else {
                $Block1 = "";
            }

            $conditions1 = $Block1;                  # e.g. Thunderstorm

            if ($Block2t) {
                if ( defined( $Converter{$Block2t} ) ) {
                    $Block2 = $Converter{$Block2t};
                }
                else {
                    $Block2 = "";
                }
                $conditions2 = $Block2;
                $Block1      = "$Block1 $Block2";
            }

            if ($old_conditionstext) {
                if ( $Block1 eq "SH" ) {
                    $conditionstext = "$Block2 of $Block1";
                    $conditions1    = "Showers of";
                }
                else {
                    $conditionstext = "$old_conditionstext and $Block1";
                }
            }
            else {
                $conditionstext = $Block1;
            }
        }
    }
    return ( $conditionstext, $conditions1, $conditions2, $intensity );
}

#------------------------------------------------------------------------------
# Lets create a new self
#------------------------------------------------------------------------------

sub new {
    my $Proto = shift;
    my $Class = ref($Proto) || $Proto || __PACKAGE__;
    my $Self  = {};

    $Self->{servername} = "tgftp.nws.noaa.gov";
    $Self->{username}   = "anonymous";
    $Self->{password}   = '[e-mail]';
    $Self->{directory}  = "/data/observations/metar/stations";
    $Self->{timeout}    = 120;
    $Self->{obs}        = "";

    bless $Self, $Class;
    return $Self;
}

#------------------------------------------------------------------------------
# Adding ability to edit server/user/directory at runtime...
#------------------------------------------------------------------------------

sub setservername {
    my $Self       = shift;
    my $Servername = shift;
    $Self->{servername} = $Servername;
    return $Self;
}

sub setusername {
    my $Self = shift;
    my $User = shift;
    $Self->{username} = $User;
    return $Self;
}

sub setpassword {
    my $Self = shift;
    my $Pass = shift;
    $Self->{password} = $Pass;
    return $Self;
}

sub setdirectory {
    my $Self = shift;
    my $Dir  = shift;
    $Self->{directory} = $Dir;
    return $Self;
}

sub settemplatefile {
    my $Self  = shift;
    my $Tfile = shift;
    $Self->{tfile} = $Tfile;
    return $Self;
}

sub settimeout {
    my $Self    = shift;
    my $Seconds = shift;
    $Self->{timeout} = $Seconds;
    return $Self;
}

#------------------------------------------------------------------------------
# Here we get to FTP to the NWS and get the data
#------------------------------------------------------------------------------

sub getreporthttp {
    my $Self = shift;
    my $Code = shift;

# The old site was: http://weather.noaa.gov/cgi-bin/mgetmetar.pl?cccc=$Code
# Also outdated:
# 'http://www.aviationweather.gov/adds/metars/?station_ids=' . $Code . '&chk_metars=on&hoursStr=most+recent+only';

    # We'll keep using the raw METAR report to minimize changes for now.
    # The new API could parse out the elements for us.
    $Self->{http}
        = 'https://aviationweather.gov/api/data/metar?ids='
        . $Code
        . '&format=raw&taf=false&hours=0';
    my $Ret = &getreport( $Self, $Code );
    return $Ret;
}

sub getreport {
    my $Self    = shift;
    my $Station = shift;

    $Self->{error} = "0";

    my $Tmphandle = File::Temp->new();
    my $Tmpfile   = $Tmphandle->filename;
    close $Tmphandle;

    my $Code = uc($Station);

    if ( !$Code ) {
        $Self->{error}     = "1";
        $Self->{errortext} = "No Station Code Entered\n";
        return $Self;
    }

    if ( $Self->{http} && $Self->{http} ne "" ) {
        my $Ua = LWP::UserAgent->new();
        $Ua->agent("Geo::WeatherNWS $VERSION");

        my $Req = HTTP::Request->new( GET => $Self->{http} );
        $Req->content_type('application/x-www-form-urlencoded');
        my $Res = $Ua->request($Req);

        if ( $Res->is_success ) {
            $Self->{obs} = $Res->content;
            $Self->{obs} =~ s/^METAR //;
        }
    }
    else {

        # Some users needed this for firewalls...
        my $Ftp = Net::FTP->new(
            $Self->{servername},
            Debug   => 0,
            Passive => 1,
            Timeout => $Self->{timeout}
        );

        # my $Ftp=Net::FTP->new($Self->{servername}, Debug => 0);
        if ( !defined $Ftp ) {
            $Self->{error}     = 1;
            $Self->{errortext} = "Cannot connect to $Self->{servername}: $@";
            return $Self;
        }
        $Ftp->login( $Self->{username}, $Self->{password} );
        my $Rcode   = $Ftp->code();
        my $Message = $Ftp->message();

        if ( $Rcode =~ /^[45]/ ) {
            $Self->{error}     = $Rcode;
            $Self->{errortext} = $Message;
            return $Self;
        }

        $Ftp->cwd( $Self->{directory} );
        $Rcode   = $Ftp->code();
        $Message = $Ftp->message();

        if ( $Rcode =~ /^[45]/ ) {
            $Self->{error}     = $Rcode;
            $Self->{errortext} = $Message;
            return $Self;
        }

        $Rcode   = $Ftp->get( "$Code.TXT", $Tmpfile );
        $Rcode   = $Ftp->code();
        $Message = $Ftp->message();
        $Ftp->quit;

        if ( $Rcode =~ /^[45]/ ) {
            $Self->{error}     = $Rcode;
            $Self->{errortext} = $Message;
            return $Self;
        }

        local $/;    # enable slurp mode
        open my $F, '<', $Tmpfile
            or croak "error opening temp input $Tmpfile: $!";
        my $Data = <$F>;
        close($F);
        unlink($Tmpfile);

        $Data =~ tr/\n/ /;
        $Self->{obs} = $Data;
    }

    $Self->decode();
    return $Self;
}

#------------------------------------------------------------------------------
# Decodeobs takes the obs in a string format and decodes them
#------------------------------------------------------------------------------

sub decodeobs {
    my $Self = shift;
    my $Obs  = shift;
    $Self->{obs} = $Obs;
    $Self->decode();
    return $Self;
}

#------------------------------------------------------------------------------
# Decode does the work, and is only called internally
#------------------------------------------------------------------------------

sub decode {
    my $Self = shift;
    my @Cloudlevels;

    my @Splitter = split( /\s+/, $Self->{obs} );

#------------------------------------------------------------------------------
# Break the METAR observations down and decode
#------------------------------------------------------------------------------

    my $have_icao_code = 0;
    my $column         = 0;

    $Self->{cloudcover}        = "";
    $Self->{conditions1}       = "";
    $Self->{conditions2}       = "";
    $Self->{conditionstext}    = "";
    $Self->{dewpoint_c}        = "";
    $Self->{dewpoint_f}        = "";
    $Self->{error}             = "" if !defined $Self->{error};
    $Self->{errortext}         = "" if !defined $Self->{errortext};
    $Self->{eventbe}           = "";
    $Self->{heat_index_c}      = "";
    $Self->{heat_index_f}      = "";
    $Self->{http}              = "" if !defined $Self->{http};
    $Self->{intensity}         = "";
    $Self->{maintenance}       = "";
    $Self->{precipslr}         = "";
    $Self->{pressure_inhg}     = "";
    $Self->{pressure_kgcm}     = "";
    $Self->{pressure_lbin}     = "";
    $Self->{pressure_mb}       = "";
    $Self->{pressure_mmhg}     = "";
    $Self->{ptemperature}      = "";
    $Self->{relative_humidity} = "";
    $Self->{slp_inhg}          = "";
    $Self->{slp_kgcm}          = "";
    $Self->{slp_lbin}          = "";
    $Self->{slp_mb}            = "";
    $Self->{slp_mmhg}          = "";
    $Self->{storm}             = "";
    $Self->{temperature_c}     = "";
    $Self->{temperature_f}     = "";
    $Self->{templateout}       = "" if !defined $Self->{templateout};
    $Self->{tfile}             = "" if !defined $Self->{tfile};
    $Self->{thpressure}        = "";
    $Self->{thpressure}        = "";
    $Self->{visibility_km}     = "";
    $Self->{visibility_mi}     = "";
    $Self->{windchill_c}       = "";
    $Self->{windchill_f}       = "";
    $Self->{winddir}           = "";
    $Self->{winddirtext}       = "";
    $Self->{windgustkmh}       = "";
    $Self->{windgustkts}       = "";
    $Self->{windgustmph}       = "";
    $Self->{windspeedkmh}      = "";
    $Self->{windspeedkts}      = "";
    $Self->{windspeedmph}      = "";

    foreach my $Line (@Splitter) {
        $column++;

#------------------------------------------------------------------------------
# Report date and time
# These aren't always present (for example, from the http interface)
#------------------------------------------------------------------------------

        if ( $column == 1 && $Line =~ /^\d{4}\/\d{2}\/\d{2}$/ ) {
            $Self->{report_date} = $Line;
        }

        if ( $column == 2 && $Line =~ /^\d{2}:\d{2}$/ ) {
            $Self->{report_time} = $Line;
        }

#------------------------------------------------------------------------------
# ICAO station code
#------------------------------------------------------------------------------

        if (   ( $Line =~ /^([A-Z][A-Z0-9]{3})/ )
            && ( !$have_icao_code ) )
        {
            # Use the first value that looks like the ICAO code.
            # This should either be the first item, or
            # the third item if there is a leading date and time.
            # (Before we checked have_icao_code, we'd get values
            # like TSRA or FZFG later in the observation being treated
            # as the ICAO code.)
            # We also allow the last three characters to be digits.

            # There was a check for "AUTO" above before, for now
            # we'll add an extra check for that value. (AUTO should
            # show up in the fifth column.)
            croak "Unexpected value AUTO for ICAO code" if $Line eq "AUTO";

            $Self->{code} = $Line;
            $have_icao_code = 1;
        }

#------------------------------------------------------------------------------
# Report Time
#------------------------------------------------------------------------------

        elsif ( $Line =~ /([0-9]Z)$/ ) {
            my $Timez = substr( $Line, 2, 4 );
            $Self->{time} = $Timez;
            $Self->{day}  = substr( $Line, 0, 2 );
        }

#------------------------------------------------------------------------------
# Wind speed and direction
#------------------------------------------------------------------------------

        elsif ( $Line =~ /([0-9]KT)$/ ) {
            my $Newline;
            my $Variable;

            if ( $Line =~ /VRB/ ) {
                $Newline  = substr( $Line, 3 );
                $Variable = "1";
            }
            else {
                $Newline = $Line;
            }

            my $Winddir = substr( $Newline, 0, 3 );
            $Winddir =~ tr/[A-Z]/ /d;
            $Winddir = $Winddir - 0;
            my $Winddirtxt;

            if ($Variable) {
                $Winddirtxt = "Variable";
            }
            elsif ( ( $Winddir <= 22.5 ) || ( $Winddir >= 337.5 ) ) {
                $Winddirtxt = "North";
            }
            elsif ( ( $Winddir <= 67.5 ) && ( $Winddir >= 22.5 ) ) {
                $Winddirtxt = "Northeast";
            }
            elsif ( ( $Winddir <= 112.5 ) && ( $Winddir >= 67.5 ) ) {
                $Winddirtxt = "East";
            }
            elsif ( ( $Winddir <= 157.5 ) && ( $Winddir >= 112.5 ) ) {
                $Winddirtxt = "Southeast";
            }
            elsif ( ( $Winddir <= 202.5 ) && ( $Winddir >= 157.5 ) ) {
                $Winddirtxt = "South";
            }
            elsif ( ( $Winddir <= 247.5 ) && ( $Winddir >= 202.5 ) ) {
                $Winddirtxt = "Southwest";
            }
            elsif ( ( $Winddir <= 292.5 ) && ( $Winddir >= 247.5 ) ) {
                $Winddirtxt = "West";
            }
            elsif ( ( $Winddir <= 337.5 ) && ( $Winddir >= 292.5 ) ) {
                $Winddirtxt = "Northwest";
            }

            my $Windspeedkts = substr( $Line, 3 );
            my $Windgustkts  = 0;

            if ( $Windspeedkts =~ /G/ ) {
                my @Splitter = split( /G/, $Windspeedkts );

                $Windspeedkts = $Splitter[0];
                $Windgustkts  = $Splitter[1];
            }

            $Windspeedkts =~ tr/[A-Z]//d;
            $Windgustkts  =~ tr/[A-Z]//d;

            if ( $Windspeedkts == 0 ) {
                $Winddirtxt = "Calm";
            }

            my $MPH  = round( convert_kts_to_mph($Windspeedkts) );
            my $GMPH = round( convert_kts_to_mph($Windgustkts) );
            my $KMH  = round( convert_kts_to_kmh($Windspeedkts) );
            my $GKMH = round( convert_kts_to_kmh($Windgustkts) );

            $Self->{windspeedkts} = $Windspeedkts;
            $Self->{windgustkts}  = $Windgustkts;
            $Self->{windspeedkts} = $Self->{windspeedkts} - 0;
            $Self->{windspeedmph} = $MPH;
            $Self->{windspeedkmh} = $KMH;
            $Self->{windgustmph}  = $GMPH;
            $Self->{windgustkmh}  = $GKMH;
            $Self->{winddirtext}  = $Winddirtxt;
            $Self->{winddir}      = $Winddir;
            $Self->{winddir}      = $Self->{winddir} - 0;
        }

#------------------------------------------------------------------------------
# Current Visibility
#------------------------------------------------------------------------------

        elsif ( $Line =~ /([0-9]SM)$/ ) {
            $Line =~ tr/[A-Z]//d;

#------------------------------------------------------------------------------
# Some stations were reporting fractions for this value
#------------------------------------------------------------------------------

            if ( $Line =~ /\// ) {
                my @Splitter = split( /\//, $Line );
                $Line = $Splitter[0] / $Splitter[1];
            }

            my $Viskm = convert_miles_to_km($Line);
            $Self->{visibility_mi} = round($Line);
            $Self->{visibility_km} = round($Viskm);
        }

#------------------------------------------------------------------------------
# Current Conditions
#------------------------------------------------------------------------------

        elsif (
            (   $Line =~ /
                (BR|TS|MI|PR|BC|DR|BL|SH|FZ|DZ|RA|SN|SG|IC|PE|PL|GR|GS|UP|FG|FU|VA|DU|SA|HZ|PY|PO|SQ|FC|SS)
                ([A-Z])*
              /x
            )
            || ( $Line =~ /^VC([A-Z])*/ )
            || ( $Line =~ /[\+\-]VC([A-Z])*/ )
            )
        {
            my ( $conditionstext, $conditions1, $conditions2, $intensity )
                = translate_weather( $Line, $Self->{conditionstext},
                $Self->{conditions1}, $Self->{conditions2} );
            $Self->{conditionstext} = $conditionstext
                if defined $conditionstext;
            $Self->{conditions1} = $conditions1 if defined $conditions1;
            $Self->{conditions2} = $conditions2 if defined $conditions2;
            $Self->{intensity}   = $intensity   if defined $intensity;
        }

#------------------------------------------------------------------------------
# Cloud Cover
#------------------------------------------------------------------------------

        elsif (( $Line =~ /^(VV[0-9])/ )
            || ( $Line =~ /^(SKC[0-9])/ )
            || ( $Line =~ /^(CLR)/ )
            || ( $Line =~ /^(FEW)/ )
            || ( $Line =~ /^(SCT[0-9])/ )
            || ( $Line =~ /^(BKN[0-9])/ )
            || ( $Line =~ /^(OVC[0-9])/ ) )
        {

            push( @Cloudlevels, $Line );

            $Self->{cloudcover} = "";
            if ( $Line =~ /^(CLR)/ ) {
                $Self->{cloudcover} = "Clear";
            }
            elsif ( $Line =~ /^(FEW)/ ) {
                $Self->{cloudcover} = "Fair";
            }
            elsif ( $Line =~ /^(SCT[0-9])/ ) {
                $Self->{cloudcover} = "Partly Cloudy";
            }
            elsif ( $Line =~ /^(BKN[0-9])/ ) {
                $Self->{cloudcover} = "Mostly Cloudy";
            }
            elsif ( $Line =~ /^(OVC[0-9])/ ) {
                $Self->{cloudcover} = "Cloudy";
            }

            if ( !$Self->{conditionstext} ) {
                $Self->{conditionstext} = $Self->{cloudcover};
            }
        }

#------------------------------------------------------------------------------
# Get the temperature/dewpoint and calculate windchill/heat index
#------------------------------------------------------------------------------

        elsif (( $Line =~ /^([0-9][0-9]\/[0-9][0-9])/ )
            || ( $Line =~ /^(M[0-9][0-9]\/)/ )
            || ( $Line =~ /^(M[0-9][0-9]\/M[0-9][0-9])/ )
            || ( $Line =~ /^([0-9][0-9]\/M[0-9][0-9])/ ) )
        {
            my @Splitter    = split( /\//, $Line );
            my $Temperature = $Splitter[0];
            my $Dewpoint    = $Splitter[1];
            if ( !defined $Dewpoint ) {
                $Dewpoint = "";
            }

            if ( $Temperature =~ /M/ ) {
                $Temperature =~ tr/[A-Z]//d;
                $Temperature = ( $Temperature - ( $Temperature * 2 ) );
            }
            $Temperature += 0;

            if ( $Dewpoint =~ /M/ ) {
                $Dewpoint =~ tr/[A-Z]//d;
                $Dewpoint = ( $Dewpoint - ( $Dewpoint * 2 ) );
            }
            if ( $Dewpoint ne "" ) {
                $Dewpoint += 0;
            }

            my $Tempf = convert_c_to_f($Temperature);
            my $Dewf  = convert_c_to_f($Dewpoint);

            my $rh = "";
            if ( defined $Dewpoint && $Dewpoint ne "" ) {
                my $Es = 6.11
                    * 10.0**( 7.5 * $Temperature / ( 237.7 + $Temperature ) );
                my $E = 6.11
                    * 10.0**( 7.5 * $Dewpoint / ( 237.7 + $Dewpoint ) );
                $rh = round( ( $E / $Es ) * 100 );
            }

            my $F = $Tempf;

            my $Heati  = heat_index( $F, $rh );
            my $Heatic = convert_f_to_c($Heati);

            $Tempf  = round($Tempf);
            $Dewf   = round($Dewf);
            $Heati  = round($Heati);
            $Heatic = round($Heatic);

            my $Windc  = windchill( $F, $Self->{windspeedmph} );
            my $Windcc = convert_f_to_c($Windc);
            $Windc  = round($Windc);
            $Windcc = round($Windcc);

            $Self->{temperature_c}     = $Temperature;
            $Self->{temperature_f}     = $Tempf;
            $Self->{dewpoint_c}        = $Dewpoint;
            $Self->{dewpoint_f}        = $Dewf;
            $Self->{relative_humidity} = $rh;
            $Self->{heat_index_c}      = $Heatic;
            $Self->{heat_index_f}      = $Heati;
            $Self->{windchill_c}       = $Windcc;
            $Self->{windchill_f}       = $Windc;
        }

#------------------------------------------------------------------------------
# Calculate the atmospheric pressure in different formats.
# Based on report (inches of mercury)
#------------------------------------------------------------------------------

        elsif ( $Line =~ /^(A[0-9]{4})/ ) {
            $Line =~ tr/[A-Z]//d;
            my $Part1 = substr( $Line, 0, 2 );
            my $Part2 = substr( $Line, 2, 4 );
            $Self->{pressure_inhg} = "$Part1.$Part2";

            my $mb   = $Self->{pressure_inhg} * 33.8639;
            my $mmHg = $Self->{pressure_inhg} * 25.4;
            my $lbin = ( $Self->{pressure_inhg} * 0.491154 );
            my $kgcm = ( $Self->{pressure_inhg} * 0.0345316 );
            $mb   = round($mb);
            $mmHg = round($mmHg);

            $Self->{pressure_mb}   = $mb;
            $Self->{pressure_mmhg} = $mmHg;
            $Self->{pressure_lbin} = $lbin;
            $Self->{pressure_kgcm} = $kgcm;
        }

#------------------------------------------------------------------------------
# Calculate the atmospheric pressure in different formats.
# Based on report (millibars)
#------------------------------------------------------------------------------

        elsif ( $Line =~ /^(Q[0-9]{4})/ ) {
            $Line =~ tr/[A-Z]//d;
            $Self->{pressure_mb} = $Line;

            my $inhg = ( $Self->{pressure_mb} * 0.02953 );
            $Self->{pressure_inhg} = sprintf( "%.2f", $inhg );
            my $mmHg = $Self->{pressure_inhg} * 25.4;
            my $lbin = ( $Self->{pressure_inhg} * 0.491154 );
            my $kgcm = ( $Self->{pressure_inhg} * 0.0345316 );
            $mmHg = round($mmHg);

            $Self->{pressure_mmhg} = $mmHg;
            $Self->{pressure_lbin} = $lbin;
            $Self->{pressure_kgcm} = $kgcm;
        }

#------------------------------------------------------------------------------
# If the remarks section is starting, we are done
#------------------------------------------------------------------------------

        elsif ( $Line =~ /^(RMK)/ ) {
            last;
        }
    }

#------------------------------------------------------------------------------
# Read the remarks into an array for later processing
#------------------------------------------------------------------------------

    my $Remarks = 0;
    my @Remarkarray;

    foreach my $Line (@Splitter) {
        if ( $Line =~ /^(RMK)/ ) {
            $Remarks = 1;
        }

        if ($Remarks) {
            push( @Remarkarray, $Line );
        }
    }

#------------------------------------------------------------------------------
# Delete the temp file
#------------------------------------------------------------------------------

    $Self->{cloudlevel_arrayref} = \@Cloudlevels;
    $Self->{station_type}        = "Manual";

#------------------------------------------------------------------------------
# Now we process remarks.  These aren't all going to be in the report,
# and usually aren't.  This has made it hard to develop.  This section
# is basically incomplete, but you can get some of the data out
#------------------------------------------------------------------------------

    foreach my $Remark (@Remarkarray) {
        if ($Remark) {
            my $Line = $Remark;

            if ( $Remark =~ /^AO[1-2]/ ) {
                $Self->{station_type} = "Automated";
            }
            elsif ( $Remark =~ /^SLP/ ) {
                $Remark =~ tr/[A-Z]//d;

                if ( !defined $Remark || $Remark eq "" ) {
                    $Remark = 0;
                }

                if ( ($Remark) && ( $Remark >= 800 ) ) {
                    $Remark = $Remark * .1;
                    $Remark = $Remark + 900;
                }
                else {
                    $Remark = $Remark * .1;
                    $Remark = $Remark + 1000;
                }

                $Self->{slp_inhg} = ( $Remark * 0.0295300 );
                $Self->{slp_inhg} = substr( $Self->{slp_inhg}, 0, 5 );
                $Self->{slp_mmhg} = round( $Remark * 0.750062 );
                $Self->{slp_lbin} = ( $Remark * 0.0145038 );
                $Self->{slp_kgcm} = ( $Remark * 0.00101972 );
                $Self->{slp_mb}   = round($Remark);
            }

#------------------------------------------------------------------------------
# Thunderstorm info
#------------------------------------------------------------------------------

            elsif ( $Remark =~ /^TS/ ) {
                $Self->{storm} = $Remark;
            }

#------------------------------------------------------------------------------
# Three hour pressure tendency
#------------------------------------------------------------------------------

            elsif ( $Remark =~ /^5[0-9]/ ) {
                $Self->{thpressure} = $Remark;
            }

#------------------------------------------------------------------------------
# Automated station needs maintenance
#------------------------------------------------------------------------------

            elsif ( $Remark =~ /\$/ ) {
                $Self->{maintenance} = $Remark;
            }

#------------------------------------------------------------------------------
# Precipitation since last report (100ths of an inch)
#------------------------------------------------------------------------------

            elsif ( $Remark =~ /^P[0-9]/ ) {
                $Self->{precipslr} = $Remark;
            }

#------------------------------------------------------------------------------
# Event beginning or ending
#------------------------------------------------------------------------------

            elsif ( $Line
                =~ /^(BRB|TSB|MIB|PRB|BCB|DRB|BLB|SHB|FZB|DZB|RAB|SNB|SGB|ICB|PEB|GRB|GSB|UPB|FGB|FUB|VAB|DUB|SAB|HZB|PYB|POB|SQB|FCB|SSB)/
                )
            {
                $Self->{eventbe} = $Remark;
            }

#------------------------------------------------------------------------------
# Precise temperature reading
#------------------------------------------------------------------------------

            elsif ( $Remark =~ /^T[0-9]/ ) {
                $Self->{ptemperature} = $Remark;
            }
        }
    }

    my $Templatefile = $Self->{tfile};

    if ( $Templatefile && $Templatefile ne "" ) {
        local $/;    # enable slurp mode
        open my $F, '<', $Templatefile
            or croak "error opening template file $Templatefile: $!";
        my $tout = <$F>;
        close($F);

        $tout =~ s{ %% ( .*? ) %% }
                        { exists( $Self->{$1} )
                                ? $Self->{$1}
                                : ""
                        }gsex;

        $Self->{templateout} = $tout;
    }

    $Self->{remark_arrayref} = \@Remarkarray;
    return $Self;
}

1;
__END__