An alternative would be to let the r.g.b/24 subnet produce the color. That is simple, direct and irreversable, but still meaningful to the eye.

sub ip2rgb {
    my @ip = @_;
    push @ip, (0) x 3;
    @ip[0..2];
}
[download]

That takes the ip quad as a list of octets. The Socket::inet_*() functions can be used to convert address forms.

Probably not too useful, but the last octet could be used for transparency.
-- Argel

Why not choose a list of colors, a suitable hash function for IPs, and use $color{hash(@ip)}?

MD5 could be used as a hash function here on the IP-string (or any string as a matter of fact), and the first 3 pairs of hex-characters could be used as rgb values:

#!/usr/bin/perl -l
use strict;
use Digest::MD5 qw(md5_hex);


my $ip="192.168.7.1";
my $ip2="192.168.7.2";
my $ip3="192.168.7.3";
my $ip4="192.168.7.4";

print join(",", ip2color($ip));
print join(",", ip2color($ip2));
print join(",", ip2color($ip3));
print join(",", ip2color($ip4));

sub ip2color {
        my ($ip) = @_;
        my $md5 = md5_hex($ip);
        my @rgb;
        foreach (0 .. 2) {
                my $value_in_hex = substr($md5,0+2*$_,2);
                push @rgb, hex($value_in_hex);
        }
        return @rgb;
}
__DATA__
251,180,114
35,50,113
80,124,60
221,201,172
[download]

Not meaningful for the eye these colors (like Zaxo's solution), but neighboring IPs very likely will have different colors.

Indeterminate really; visitors' IPs from anywhere. Assume all of them. :) I liked Zaxo's below and I'm going to play with it. Love to see more ideas too. Just for fun.

#!/usr/bin/perl -w

use strict;

my @octets = split(/\./, $ENV{'REMOTE_ADDR'});
pop(@octets);

my @hexval;
push(@hexval, dec2hex($_)) for (@octets);
my $hex = join("", @hexval);

print "Content-type: text/html; charset=ISO-8859-1\n\n";
print "The hex value is: <font color=$hex>$hex</font>\n";

sub dec2hex {
   my $decnum = shift;

   my ($hexnum, $modulus, @hexval);

   $hexnum = int($decnum / 16);
   $hexnum = chr($hexnum + 55) if ($hexnum > 9);

   push(@hexval, $hexnum);

   $modulus = $decnum % 16;
   $modulus = chr($modulus + 55) if ($modulus > 9);

   push(@hexval, $modulus);
   return join("", @hexval);
}
[download]

Not sure how you plan on making it irreversible. If you use the method of converting the IP into a hex number it will always be able to be reversed if anyone figures out how you vreate the hex. However all that will be able to be recovered is the first three octets. Also with this method you have the possibility of having 253 users (255 minus 1 for broadcast and one for gateway) with the same color. Be it a very very small chance that every user from that IP range will visit your site at once.

I think using MD5 (as i demonstrated above) sort-of solves this irreversibility-problem. MD5 is a one-way hashing algorithm, so in principle you'll only be able to get back from rgb-value to IP if you have a full table of IP to rgb-value's (a 'brute force' attack). MD5 is not the strongest of one-way hashing algoritms, but it's widely used and widely available.

From a usability stand point I think that you don't want to use the full range of RGB colors. Otherwise you may have a color like #F0E7FA appear on a white page and be nearly invisable.

The easyest way to do that would be to set the most significant bit of each byte of the RGB value to 0 for light backgrounds and 1 for dark backgrounds. This limits the color space to only 21 bits, however setting only one of the most significant bits opposite of the others doesn't move the color too far to make text illegable to me, so picking one or none of the 3 bits gives 4 options, or to look at it another way restores 2 bits to the color space without sacrificing readability of the text.

In my code I do this by using the last 3 bytes of the IP address for the base RGB values, shifting off the least significant bit. Then take the first byte and and xor each 2 bit group with the others to get a 2 bit number to select which byte to set the most significant bit. Finely a flag toggles all the most significant bits if the text should be bright. I think this would effectivly hide the IP address while still keeping many 'close' ip addresses close in color. (though the choice of using the first byte of the IP address to affect the most significant bits by xoring it together will place many distant IP addresses near each other in the color space.)

sub ip2rgb {
    my $ip = shift;
    my $bright = shift;
    my @octets = split /\./, $ip;
    my $mso = shift @octets;
    my @rgb = map { $_ >> 1 } @octets;
    my $msb = ($mso >> 6 & 0x03) ^ ($mso >> 4 & 0x03) ^ ($mso >> 2 & 0
+x03) ^ ($mso >> 2 & 0x03) ^ ($mso & 0x03);
    if ($msb != 3) {
        $rgb[$msb] |= 0x80;
    }
    if ($bright) {
        for (@rgb) {
            $_ ^= 0x80;
        }
    }
    return @rgb;
}
[download]

use strict;
use warnings;

my @ips = qw(
    127.0.0.1
    192.172.24.23
    172.25.1.86
    66.35.250.150
    209.197.123.153
    66.39.54.27
    204.74.99.100
);

for my $ip (@ips) {
    my @ip = split /\./, $ip;
    my $seed = 0;
    $seed ^= $_ for @ip;
    srand($seed);
    my ($r,$g,$b,$mask) = map { splice @ip, int(rand(scalar @ip)), 1 }
+ (1 .. @ip);
    ($r,$g,$b) = map { int(rand(2)) ? $_ ^ $mask : $_ & $mask } ($r,$g
+,$b);

    printf("%-15s => %3d %3d %3d\n",$ip,$r,$g,$b);
}
[download]

127.0.0.1       =>   0   0   0
192.172.24.23   =>   4  16 215
172.25.1.86     => 250 173 181
66.35.250.150   =>   2 212  66
209.197.123.153 => 190 170 226
66.39.54.27     =>  45  38   2
204.74.99.100   =>  96  46 168
[download]