#!/usr/bin/perl
use warnings;
use strict;
use Tk;

my $margin = 50;
my $offset = 20;   #axis offset
my $x_max = 400;
my $y_max = 400;

my $mw = tkinit;

my $scanvas = $mw->Scrolled('Canvas',
                 -width => 500, 
         -height => 500,
                 -scrollregion => [-$margin,-$margin, 
                          $x_max + $margin, 
                          $y_max + $margin + $offset ],
         -scrollbars => 'osoe',
         -bg => 'black')->pack(-expand=>1, -fill=>'both');

&build_axis();

my $canvas = $scanvas->Subwidget('scrolled');
$canvas->Tk::bind("<Button-1>", [ \&print_xy, Ev('x'), Ev('y') ]);

sub print_xy {
  my ($canv, $x, $y) = @_;
  print "(x,y) = ", $canv->canvasx($x), ", ", $y_max - $canv->canvasy(
+$y) + $offset, "\n";
}

my $subframe = $mw->Frame(-background =>'gray50')->pack(-fill => 'x');

$subframe->Button(
    -text    => "Save",
    -command => [sub {
         $canvas->update;
         my @capture=();
         my ($x0,$y0,$x1,$y1)=$canvas->bbox('all');
         @capture=('-x'=>$x0,'-y'=>$y0,-height=>$y1-$y0,-width=>$x1-$x
+0);
         $canvas -> postscript(-colormode=>'color',
                               -file=>$0.'.ps',
                   -rotate=>90,
                   -width=>800,
                   -height=>500,    
                   @capture);
                               
                  } 
   
  ]  )->pack;




$subframe->Button(-text =>'Exit',
            -background => 'hotpink',
            -activebackground => 'red',
        -command => sub{ exit }
            )->pack(-side=>'left',-padx=>40);




while( <DATA> ){
 chomp;
 my ($x,$y,$var) = split / /,$_;
 
 my $hexcolor =  sprintf "%x", $var + 2000;
 print $hexcolor,"\n";  
  my $circle=$canvas->createOval($x, $y, $x + 10, $y + 10,
       -fill => '#'.$hexcolor.$hexcolor.$hexcolor,
    );

}


MainLoop;

######################################################################
+#

sub build_axis{
# axis
my $xaxis = $scanvas->createLine( 0, $y_max + $offset, $x_max, $y_max 
++ $offset,
                          -width => 1,
              -fill => 'lightblue');

my $yaxis = $scanvas->createLine( 0, $y_max + $offset ,0,0,
                          -width => 1,
              -fill => 'lightgreen');

# x axis ticks
my $tflag;
my $labflag;
my $min =0 ;
my $hour = 0;
my $minflag = 0;
my $hourflag = 0;
my $tlength;
my $color;
for(1..$x_max){
    $tflag = 0;
    $tlength = 5;
    $color = 'white';
    $labflag = 0;

    if( ($_ % 10) == 0 ){ $tflag = 1 }  #minutes are broken into 10 se
+c intervals

    if( ($_ % 50) == 0 ){ $tlength = 15 ; 
                          $color = 'yellow'; 
                      $min++;          
              $minflag = 1;
              $labflag = 1;
              }
              
    if( ($_ % 100) == 0 ){ $tlength = 25; 
                            $color = 'hotpink'; 
                $hour++;
                $hourflag = 1;
                $labflag = 1;
                $minflag = 0;
               }

    if( $tflag ){
      $scanvas->createLine( $_, $y_max + $offset, $_, $y_max + $offset
+ + $tlength,
                          -width => 1,
              -fill => $color);

     
       
       if($labflag){
            my $label;
        if($minflag){ $label = 100*($hour + .5); }
            else { if($hourflag){ $label = $hour * 100; } }
        
      $scanvas->createText( $_,  $y_max + $offset + 1.2*$tlength,
                           -text => $label,
                       -fill => $color,
               -anchor => 'n',
               );
           }
     }
}

# y axis ticks
my $uflag;
my $midflag;

my @array = reverse(0..$y_max );

for(@array){
    my $num = $y_max - $_;  #reverse normal axis
    $tflag = 0;
    $tlength = 5;
    $color = 'white';
    $uflag = 0;
    $midflag = 0;
    $labflag = 0;
    if( ($num % 10) == 0 ){ $tflag = 1 }
    if( ($num % 50) == 0 ){ $tlength = 10 ; 
                          $color = 'yellow'; 
              $midflag = 1;
              $labflag = 1;
              }
              
    if( ($num % 100) == 0 ){ $tlength = 20; 
                            $color = 'hotpink'; 
                            $uflag = 1;
                $labflag = 1;
                $midflag = 0;
               }

    if( $tflag ){
      $scanvas->createLine( 0 - $tlength, $num + $offset, 0, $num + $o
+ffset,
                          -width => 1,
              -fill => $color);
     
       
       if($labflag){
            my $label;
        if($midflag){ $label =  $num; }
            if($uflag){ $label =  $num; }
        
      $scanvas->createText( -20 ,  $y_max + $offset - $num ,
                           -text => $label,
                       -fill => $color,
               -anchor => 'e',
               );
           }
     }
 }

$scanvas->xview('moveto',0);
$scanvas->yview('moveto',1);

}

__DATA__
10 100 45
10 200 50
30 300 60
400 400 500
[download]

Given just what you've asked, I'd say you should take a look at Imager (or possible Image::Magick or GD, although I much prefer Imager). You can easily create an image with colored boxes for your coordinates using that library.

-sam

If one imagines the first two columns as 'objects' the third column is a measure of similarity between those two objects. I want to create a 2D grid as an image (.png/.ps file or similar)

As has been said already, map the values on an array and map this array to an arbitary graphic output, like:

 ...
 use Imager;
 # OPEN FILE
 my $fn = 'datafile.dat';
 open my $fh, '<', $fn or die "$fn $!";

 # READ DATA INTO 2D MATRIX
 my @matrix = map [ qw(-1) x 40 ], 1..40;
 $matrix[$_->[1]][$_->[0]] = $_->[2] for map [split /\s+/ ], <$fh>;
 
 # PREPARE IMAGE
 my $scale=10;
 my $img = Imager->new(xsize=>40*$scale, ysize=>40*$scale, channels=>3
+);
 $img->box(filled=>1, color=>'#FFFFFF');

 # CREATE IMAGE
 for my $row (0 .. @matrix-1) {
    for my $col (0 .. @{$matrix[$row]}-1) {
       my $val = $matrix[$row][$col];
       next if $val == -1;
       # SELECT APPROPRIATE COLOR (BE CREATIVE HERE ;-)
       $img->box( color=>[ ($val/10)*25, $val*2.5, $val ],
                  filled=>1,
                  xmin=>$col*$scale,     ymin=>$row*$scale,
                  xmax=>($col+1)*$scale, ymax=>($row+1)*$scale )
    }
 }
 # DUMP IMAGE TO FILE
 $img->write(file=>'my.jpg', jpegquality=>90) or die $img->errstr;
 ...
[download]

(This is my first shot at Imager - after sams remark - and therefore the reason that I posted this, so feel free to give hints ...)

Regards

mwa

Modification #1:

• allow "black" squares to be drawn (similarity == 0): inititialize with -1
• use filename and a lexical filehandle
• don't draw anything if nothing got into the matrix cell (next if ...)

Because it's Perl, I think I may try another shot (semi-golf version):

 use Imager;
 my ($n, $fac) = (40, 10);               # 2D-SIZE, FACTOR TO IMAGE
 my $fn = shift || 'datafile.dat';       
 open my $fh, '<', $fn or die "$fn $!";  # OPEN FILE
 my $img = Imager->new(xsize=>$n*$fac, ysize=>$n*$fac, channels=>3);
 $img->box(filled=>1, color=>'#FFFFFF'); # BACKGROUND
 $img->box(color=>[($_->[2]/10)*25, $_->[2]*2.5, $_->[2] ], filled=>1,
           xmax=>($_->[0]+1)*$fac, ymax=>($_->[1]+1)*$fac,
           xmin=>$_->[0]*$fac, ymin=>$_->[1]*$fac) for map [split /\s+
+/], <$fh>;
 $img->write(file=>'my.jpg', jpegquality=>90) or die $img->errstr;
[download]

the 2D matrix storage is't really necessary, this can be handled in "mid-air" ...

Regards

mwa