/***************************************************************************
calibrate_ppa.c - program to produce PPM data for pnm2ppa calibration
-------------------
begin : Thu Oct 12 2000
copyright : (C) 1998-2000 by the pnm2ppa project
email :
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
/* incorporates color features added by Bruno ALIX */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <getopt.h>
#include <sys/param.h>
#define __PNM2PPA_C__
#define __CALIBRATE_PPA_C__
#include "global.h"
#include "image.h"
#include "defaults.h"
#include "pnmtools.h"
int make_ppm_file ( FILE * , image_t *, char *) ;
int make_test_pattern ( FILE *, int, char * );
/* int black_maxlines = 300; */
int black_maxlines = 128; /*put this back to old value for now (duncan)*/
void
show_usage (char *prog)
{
printf ("usage: %s [ options ] [ -o <outfile> ]] \n\n",
prog);
printf
(" Produces various PixMap (PPM) files used for calibrating pnm2ppa.\n\n");
printf (" NOTE: The size of a full-page PixMap is 100MB!!.\n");
printf (" These PixMaps should be piped directly to pnm2ppa, except in the case of\n");
printf (" the -g option, where the PixMap should be viewed or printed by other means.\n\n");
printf (" -g, --gamma produce gamma.ppm (10MB, used in color calibration).\n");
printf (" -h, --help displays this help text.\n");
printf (" -o <outfile> output to file <outfile>, \"-o -\" means stdout (default)\n");
printf (" -p <n> create test pattern number <n>\n");
printf (" --align pattern 0: align print heads. (default) \n");
printf (" --test pattern 1: test alignment. \n");
printf (" --clean pattern 2: clean print head. \n");
printf (" --center pattern 3: center paper. \n");
printf (" -s <paper> default papersize (a4, legal, letter = us (default))\n");
#if 0
printf (" -v <printer> Printer model:710=712=720=722;820;1000 (default:7xx)\n");
#endif
printf ("\n");
}
int
main (int argc, char *argv[])
{
int opt_index;
image_t image ;
char *progname = NULL;
BOOLEAN use_stdout = true ;
BOOLEAN gamma = false ;
FILE *outFile = NULL ;
int testPattern = 0;
char *out_filepath = NULL;
char c;
static struct option long_opts[] = {
{"gamma",0,0,'g'},
{"align",0,0,0},
{"test",0,0,0},
{"clean",0,0,0},
{"center",0,0,0},
{"help",0,0,'h'},
{0, 0, 0, 0}
};
gWidth = LETTERWIDTH;
gHeight = LETTERHEIGHT ;
/* read through the optional arguments before tring to find filenames */
while ((c = getopt_long (argc, argv, "gho:p:s:v:",
long_opts, &opt_index)) != EOF)
{
progname = *argv;
switch (c)
{
case 0:
/* long options */
switch (opt_index)
{
case 0:
/* --gamma */
gamma = true;
break;
case 1:
/* --align */
gamma = false;
testPattern = 0;
break;
case 2:
/* --test */
gamma = false;
testPattern = 1;
break;
case 3:
/* --clean */
gamma = false;
testPattern = 2;
break;
case 4:
/* --center */
gamma = false;
testPattern = 3;
break;
case 5:
/* --help */
show_usage (*argv);
return 0;
break;
default:
break;
}
break;
case 'g':
gamma = true;
break;
case 'h':
show_usage (*argv);
return 0;
break;
case 'o':
if (strncmp (optarg, "-", MAXPATHLEN) == 0)
{
use_stdout = true ;
}
else
{
if ( strlen(optarg) < MAXPATHLEN )
{
char filepath[MAXPATHLEN];
strncpy(filepath, optarg, MAXPATHLEN);
out_filepath = filepath ;
use_stdout = false ;
}
}
break;
case 'p':
/* select alternate test pattern */
gamma = false;
testPattern = atoi( optarg );
break;
case 's':
/* paper size stuffer */
if (!strncmp (optarg, "us", 2) || !strncmp (optarg, "letter", 6))
{
gWidth = LETTERWIDTH;
gHeight = LETTERHEIGHT;
}
else if (!strncmp (optarg, "legal", 5))
{
gWidth = LEGALWIDTH;
gHeight = LEGALHEIGHT;
}
else if (!strncmp (optarg, "a4", 2))
{
gWidth = A4WIDTH;
gHeight = A4HEIGHT;
}
else
{
fprintf(stderr,"%s: unknown paper size \"%s\"\n",
progname, optarg);
exit (0);
}
break;
#if 0
case 'v':
/* printer model */
if (!strncmp (optarg, "820", 3) || !strncmp (optarg, "1000", 4))
black_maxlines = 128;
else if (!strncmp (optarg, "71", 2) || !strncmp (optarg, "72", 2))
/* black_maxlines = 300; */
black_maxlines = 128; /*reverted for the moment - Duncan */
else
{
fprintf(stderr,"%s: unknown printer model \"%s\"\n",
progname, optarg);
exit (0);
}
break;
#endif
default:
exit (0);
break;
}
}
if (use_stdout)
outFile = stdout;
else
{
outFile = fopen( out_filepath , "w");
fprintf(stderr,"%s: writing requested PPM data to \"%s\"\n",
progname, out_filepath);
}
if (outFile == NULL )
{
fprintf(stderr,"%s: cannot open output file \"%s\"\n",
progname, out_filepath);
return 0;
}
if ( gamma )
{
/* production of PixMap gamma.ppm */
make_ppm_file( outFile , &image, progname );
}
else
{
/* make PixMap test patterns for printer */
make_test_pattern( outFile, testPattern, progname ) ;
}
fclose (outFile);
return 1 ;
}
int
make_ppm_file (FILE *outFile , image_t *image , char * progname)
{
unsigned char *line = NULL ;
image->width = gWidth;
image->height = gHeight;
image->bufferCurLine = 0;
fprintf (outFile,
"P6\n#PPM (PixMap) Image for comparison with printed output of \"pnm2ppa -g\"\n%d %d\n255\n",
image->width, 64 + image->height / 20);
line = malloc (image->width * 3);
if (!(line))
{
fprintf(stderr,"%s: malloc failed\n",
progname);
exit (1);
}
else
{
while ( image->bufferCurLine < image->height)
{
if ( ProduceGamma (image, line ))
{
fwrite (line, sizeof (unsigned char), (image->width * 3),
outFile);
}
image->bufferCurLine++;
}
free (line);
}
return 1;
}
/* various test patterns */
void centering_grid( void );
void make_big_x( void );
void make_vertical_line( void );
void color_alignment( void );
void check_alignment( void );
void head_cleaning( void );
void color_squares( void );
void centering( void );
/* color coding scheme used */
/* each color is coded on 2 bits of 1 byte rrggbbxx
(light grey is for head cleaning)
*/
enum {
WHITE = 0xfc, /* white 11 11 11 00 = 000 = (255,255,255) */
BLACK = 0x00, /* black 00 00 00 00 = 444 = (000,000,000) */
CYAN = 0xbc, /* cyan 10 11 11 00 = 100 = (128,255,255) */
MAGENTA = 0xec, /* magenta 11 10 11 00 = 010 = (255,128,255) */
YELLOW = 0xf8, /* yellow 11 11 10 00 = 001 = (255,255,128) */
RED = 0xc0, /* red 11 00 00 00 = 044 = (255,000,000) */
GREEN = 0x30, /* green 00 11 00 00 = 404 = (000,255,000) */
BLUE = 0x0c, /* blue 00 00 11 00 = 004 = (000,000,255) */
GREY = 0xa8 /* light grey 10 10 10 00 = 111 = (128,128,128) */
};
int
make_test_pattern (FILE *outFile, int testPattern , char * progname )
{
int x;
int line, maxlines = 128 ;
/* create the pattern in strips starting at line line,
with a maximum number of lines maxlines in the strip.
*/
Width = 8*(gWidth/8); /* make Width a multiple of 8 */
Height = gHeight;
/* pixel dimensions */
#if 0
Pwidth = Width ;
Pheight = Height ;
#endif
/* each color is coded on 2 bits if 1 byte rrggbbxx */
fprintf(outFile,"P6\n# pnm2ppa calibration image\n%d %d\n255\n",
Width,Height);
for ( line = 0; line < Height ; line += maxlines )
{
BitMap_topline = line;
BitMap_bottomline = line + maxlines;
if ( BitMap_bottomline > Height)
BitMap_bottomline = Height;
BitMap_Height = BitMap_bottomline - BitMap_topline;
BitMap_Width = Width;
color_bitmap = (char *)malloc(BitMap_Width*BitMap_Height);
/* set strip to white */
memset(color_bitmap,0xff,(BitMap_Width*BitMap_Height));
switch(testPattern)
{
case 0:
color_alignment();
break;
case 1:
check_alignment();
break;
case 2:
head_cleaning();
break;
case 3:
centering();
break;
#if 0
case 4:
centering_grid();
break;
case 4:
color_squares();
break;
case 5:
make_vertical_line();
break;
case 6:
make_big_x();
break;
#endif
default:
fprintf(stderr,"%s: unknown test pattern (%d)\n",progname,testPattern);
fprintf(stderr,"test pattern 0 : cartridge alignment (default)\n");
fprintf(stderr," 1 : check alignment\n");
fprintf(stderr," 2 : colored stripes, use for head cleaning\n");
fprintf(stderr," 3 : center paper \n");
return 1;
}
for(x=0; x<BitMap_Width*BitMap_Height; x++)
{
int v, mask, i;
/* extract the data from the first 6 bits of each byte
of color_bitmap, convert to ppm format, and output it.
Each color has 4 intensities, coded in 2 bits):
0x00 : 4 drops of ink - ppm value 0
0x01 : 3 drops of ink - ppm value 8
0x02 : 1 drop of ink - ppm value 128
0x03 : 0 drops of ink - ppm value 255
*/
for(i=6 ; i > 0 ; i-=2 )
{
mask = ( 0x03 << i );
v = ((color_bitmap [x] & mask) >> i);
switch(v)
{
case 0x00: /* 4 drops of ink */
v=0x00;
break;
case 0x01: /* 3 drops of ink */
v=0x08;
break;
case 0x02: /* 1 drops of ink */
v=0x80;
break;
case 0x03: /* 0 drops of ink */
v=0xff;
}
putc(v, outFile);
}
}
free(color_bitmap);
}
return 0;
}
void
centering_grid( void )
{
/* this pattern is a grid that can be used for centering the page*/
int x,y;
char buf[128];
for(x=0; x<Width; x+=100)
for(y=0; y<Height; y+=100)
setplus(x,y,4);
for(x=0; x<Width; x+=100)
{
sprintf(buf,"%d",x);
setstring(x+3,(Height/200)*100+3,buf,3);
}
for(y=0; y<Height; y+=100)
{
sprintf(buf,"%d",y);
setstring((Width/200)*100+3,y+3,buf,3);
}
for(x=0; x<Width; x+=10)
for(y=0; y<Height; y+=100)
setplus(x,y,((x%100)==50) ? 2 : 1);
for(x=0; x<Width; x+=100)
for(y=0; y<Height; y+=10)
setplus(x,y,((y%100)==50) ? 2 : 1);
setCG(Width/2,Height/2);
}
void
make_vertical_line( void )
{
int y;
for(y=0; y<300; y++)
setpixel(Width/2,Height/2-y,BLACK);
}
void
make_big_x( void )
{
int y;
for(y=0; y<300; y++)
{
setpixel(y,y,BLACK);
setpixel(Width-1-y,Height-1-y,BLACK);
}
}
void
color_alignment( void )
{
/* add for color test, alignment pattern */
int x,y,t,shear,direction;
int vpos;
int hpos;
char buf[128];
/* horizontal black/color offset pattern */
vpos=300;
hpos=Width/2-2000;
for(y=1;y<20;y++)
{
for(x=0;x<128;x++)
{
setpixel(y*200+hpos,x+vpos,BLACK);
setpixel(y*201-10+hpos,x+vpos+128,BLUE);
setpixel(y*201-10+1+hpos,x+vpos+128,BLUE);
setpixel(y*200+hpos,x+vpos+256,BLACK);
}
if ((y-10) > 0)
sprintf(buf,"+%d",y-10);
else
sprintf(buf,"%d",y-10);
setstring(y*200+hpos,vpos+400,buf,5);
}
setstring(Width/2 -200,vpos+500,"COLOFFSX",7);
/* vertical black/color offset pattern */
vpos=1200;
hpos=Width/2-2150;
for (t=1;t<10;t++)
{
for(y=0;y<101;y++)
{
setpixel(t*400+hpos+y,vpos,BLACK);
setpixel(t*400+hpos+105+y,vpos-5+t*1,BLUE);
setpixel(t*400+hpos+105+y,vpos-5+t*1+1,BLUE);
setpixel(t*400+hpos+210+y,vpos,BLACK);
}
if ((t-5) > 0)
sprintf(buf,"+%d",t-5);
else
sprintf(buf,"%d",t-5);
setstring(t*400+hpos+150,vpos+50,buf,5);
}
setstring(Width/2-200,vpos+150,"COLOFFSY",7);
/* colorshear setting (left-to-right / right-to-left sweep offsets) */
hpos=Width/2-2000;
vpos=2000;
direction = 1; /* this is determined by whether sweep is L2R or R2L */
for(y=1;y<20;y++)
{
shear= direction*(y-10);
for(x=0;x<128;x++)
{
setpixel(y*200+hpos,x+vpos+000,BLUE);
setpixel(y*200+hpos+1,x+vpos+000,BLUE);
setpixel(y*200+hpos+shear,x+vpos+128,BLUE);
setpixel(y*200+hpos+1+shear,x+vpos+128,BLUE);
setpixel(y*200+hpos,x+vpos+256,BLUE);
setpixel(y*200+hpos+1,x+vpos+256,BLUE);
setpixel(y*200+hpos+shear,x+vpos+384,BLUE);
setpixel(y*200+hpos+1+shear,x+vpos+384,BLUE);
setpixel(y*200+hpos,x+vpos+512,BLUE);
setpixel(y*200+hpos+1,x+vpos+512,BLUE);
}
if ((y-10) > 0)
sprintf(buf,"+%d",y-10);
else
sprintf(buf,"%d",y-10);
setstring(y*200+hpos,vpos+650,buf,5);
}
setstring(Width/2-200,vpos+750,"COLORSHEAR ",7);
/* blackshear setting (left-to-right / right-to-left sweep offsets) */
hpos=Width/2-2000;
vpos=3500;
direction = -1; /* this is determined by whether sweep is L2R or R2L */
for(y=1;y<20;y++)
{
shear = -direction*(y-10);
for(x=0; x < black_maxlines ;x++)
{
setpixel(y*200+hpos,x+vpos+000,BLACK);
setpixel(y*200+hpos+shear,x+vpos+black_maxlines,BLACK);
setpixel(y*200+hpos,x+vpos+2*black_maxlines,BLACK);
setpixel(y*200+hpos+shear,x+vpos+3*black_maxlines,BLACK);
setpixel(y*200+hpos,x+vpos+4*black_maxlines,BLACK);
}
if ((y-10) > 0)
sprintf(buf,"+%d",y-10);
else
sprintf(buf,"%d",y-10);
setstring(y*200+hpos,vpos+650+5*(black_maxlines-128),buf,5);
}
vpos = vpos + 5*(black_maxlines -128) ;
setstring(Width/2-200,vpos+750,"BLACKSHEAR ",7);
hpos=Width/2;
vpos=4800;
for(x=0;x<640;x++)
{
setpixel(hpos,vpos+x,BLACK);
setpixel(hpos,vpos+640+x,BLUE);
}
}
void
check_alignment( void )
{
/* alignment verification pattern */
int x,y;
int vpos, vpos1, vpos2;
int hpos, hpos1,hpos2;
/* cross */
vpos=1000;
hpos=Width/2-384;
hpos+=384;
for (x=0;x<black_maxlines-2;x++)
setpixel(hpos,vpos+x,BLACK);
vpos += black_maxlines;
for (x=0;x<126;x++)
setpixel(hpos,vpos+x,BLUE);
vpos += 128;
for (x=0;x<black_maxlines-2;x++)
setpixel(hpos,vpos+x,BLACK);
vpos += black_maxlines;
for (x=0;x<black_maxlines-2;x++)
setpixel(hpos,vpos+x,BLACK);
vpos += black_maxlines;
for (x=0;x<126;x++)
setpixel(hpos,vpos+x,BLUE);
vpos += 128;
for (x=0;x<black_maxlines-2;x++)
setpixel(hpos,vpos+x,BLACK);
vpos += black_maxlines;
vpos-=128+2*black_maxlines;
hpos-=128+2*black_maxlines;
for (y=0;y<black_maxlines-2;y++)
setpixel(hpos+y,vpos,BLACK);
hpos += black_maxlines;
for (y=0;y<126;y++)
setpixel(hpos+y,vpos,BLUE);
hpos += 128;
for (y=0;y<black_maxlines-2;y++)
setpixel(hpos+y,vpos,BLACK);
hpos += black_maxlines;
for (y=0;y<black_maxlines-2;y++)
setpixel(hpos+y,vpos,BLACK);
hpos += black_maxlines;
for (y=0;y<126;y++)
setpixel(hpos+y,vpos,BLUE);
hpos += 128;
for (y=0;y<black_maxlines-2;y++)
setpixel(y+hpos,vpos,BLACK);
/* square */
vpos=3000;
hpos1=Width/2-3*(128+black_maxlines);
hpos2=Width/2+3*(128+black_maxlines);
for (x=0;x<2*black_maxlines -2;x++)
{
setpixel(hpos1,vpos+x,BLACK);
setpixel(hpos2,vpos+x,BLACK);
}
vpos += 2*black_maxlines;
for (x=0;x<254 ;x++)
{
setpixel(hpos1,vpos+x,BLUE);
setpixel(hpos2,vpos+x,BLUE);
}
vpos +=256;
for (x=0;x<2*black_maxlines -2;x++)
{
setpixel(hpos1,vpos+x,BLACK);
setpixel(hpos2,vpos+x,BLACK);
}
vpos += 2*black_maxlines;
for (x=0;x<254 ;x++)
{
setpixel(hpos1,vpos+x,BLUE);
setpixel(hpos2,vpos+x,BLUE);
}
vpos +=256;
for (x=0;x<2*black_maxlines -2;x++)
{
setpixel(hpos1,vpos+x,BLACK);
setpixel(hpos2,vpos+x,BLACK);
}
vpos += 2*black_maxlines;
for (x=0;x<254 ;x++)
{
setpixel(hpos1,vpos+x,BLUE);
setpixel(hpos2,vpos+x,BLUE);
}
vpos1=3000;
vpos2 = vpos1+6*(128+black_maxlines);
hpos = Width/2 - 3*(128+black_maxlines);
for (y=0;y<2*black_maxlines -2;y++)
{
setpixel(hpos+y,vpos1,BLACK);
setpixel(hpos+y,vpos2,BLACK);
}
hpos += 2*black_maxlines;
for (y=0;y<254 ;y++)
{
setpixel(hpos+y,vpos1,BLUE);
setpixel(hpos+y,vpos2,BLUE);
}
hpos +=256;
for (y=0;y<2*black_maxlines -2;y++)
{
setpixel(hpos+y,vpos1,BLACK);
setpixel(hpos+y,vpos2,BLACK);
}
hpos += 2*black_maxlines;
for (y=0;y<254 ;y++)
{
setpixel(hpos+y,vpos1,BLUE);
setpixel(hpos+y,vpos2,BLUE);
}
hpos +=256;
for (y=0;y<2*black_maxlines -2;y++)
{
setpixel(hpos+y,vpos1,BLACK);
setpixel(hpos+y,vpos2,BLACK);
}
hpos += 2*black_maxlines;
for (y=0;y<254 ;y++)
{
setpixel(hpos+y,vpos1,BLUE);
setpixel(hpos+y,vpos2,BLUE);
}
}
void
centering(void)
{
int x,y,z;
char buf[128];
for (y = Width/2; y > 0; y-- )
{
setpixel(y,y, BLACK);
setpixel(Width-y,y, BLACK);
setpixel(y,Height-y, BLACK);
setpixel(Width-y,Height-y, BLACK);
setpixel(y,Height/2, BLACK);
setpixel(Width-y,Height/2, BLACK);
}
for (x = 0; x < Height; x++)
setpixel(Width/2,x, BLACK );
for (z = 50; z < 601; z += 50)
{
for (x = z; x <= Height -z; x++)
{
setpixel(z,x,BLACK);
setpixel(Width-z,x,BLACK);
}
for (y = z; y <= Width -z;y++)
{
setpixel(y,z,BLACK);
setpixel(y,Height-z,BLACK);
}
sprintf(buf,"%d",z);
setstring (Width/2-30,z-15,buf,5);
setstring(Width/2-30,Height-z-15,buf,5);
setstringv(z-15,Height/2-60,buf,5);
setstringv(Width-z-15,Height/2-60,buf,5);
}
setstring(700,Height/2-100,"XOFFSET",7);
setstring(Width/2-150,800,"YOFFSET",7);
}
void
head_cleaning( void )
{
/* test page for cleaning */
int x,y,a,b,c;
int vpos;
char buf[128];
vpos=100;
for (y=0;y<2500;y++)
{
a=y%250 ;
b=y/50 ;
if (a==0)
{
for (x=0;x<300;x++)
{
setpixel ( y+100,x+vpos,BLACK);
}
}
else
{
for (x=0;x<6;x++)
{
a=x*50+b*1 ;
if (a>300) a=a-300;
setpixel (y+100,a+vpos,BLACK);
}
}
}
for (a=50;a<301;a+=50)
{
sprintf (buf,"%d",a);
setstring (2510+100,vpos-50+a,buf,3);
}
for (y=0;y<(240*8);y++)
{
a=y%240 ;
b=y/30 ;
vpos=500;
if (a==0)
{
for (x=0;x<128;x++)
{
setpixel ( y+100,x+vpos,MAGENTA);
setpixel ( y+100,x+vpos+128,YELLOW);
setpixel ( y+100,x+vpos+256,CYAN);
}
}
else
{
for (x=0;x<1;x++)
{
a=x*50+b*2 ;
if (a>128) a=a-128;
setpixel (y+100,a+vpos,MAGENTA);
setpixel (y+100,a+vpos+128,YELLOW);
setpixel (y+100,a+vpos+256,CYAN);
}
}
}
vpos=1300;
for (y=0;y<3500;y++)
{
a=y/500;
switch (a)
{
case 0 : b = RED; break;
case 1 : b = MAGENTA; break;
case 2 : b = BLUE; break;
case 3 : b = CYAN; break;
case 4 : b = GREEN; break;
case 5 : b = YELLOW; break;
case 6 : b = RED; break;
}
for (x=0;x<128;x++)
{
setpixel (y+100,x+vpos,b);
}
}
/*grey*/
vpos=2000;
for (y=100;y<Width-1000;y++)
{
for (x=0;x<128;x++)
{
setpixel (y,x+vpos,GREY);
}
}
/*magenta,yellow,cyan*/
vpos=2300;
for (y=100;y<Width-1000;y++)
{
for (x=0;x<128;x++)
{
setpixel (y,x+vpos,MAGENTA);
setpixel (y,x+vpos+128,YELLOW);
setpixel (y,x+vpos+256,CYAN);
}
}
/*black*/
vpos=2800;
for (y=100;y<Width-1000;y++)
{
for (x=0;x<300;x++)
{
setpixel (y,x+vpos,BLACK);
}
}
vpos=3800;
for (y=0;y<600;y++)
{
a=y%50 ;
b=y/50 ;
c=y/100;
if (a==0)
{
for (x=0;x<300;x++)
{
setpixel ( y+100,x+vpos,BLACK);
}
}
else
{
for (x=0;x<25;x++)
{
a=x*2+c*50 ;
a=a+(b%2);
setpixel (y+100,a+vpos,BLACK);
}
}
}
for (y=600;y<1701;y++)
{
a=y%50 ;
b=y/50 ;
if (a==0)
{
for (x=0;x<300;x++)
{
setpixel ( y+100,x+vpos,BLACK);
}
}
else
{
for (x=0;x<7;x++)
{
a=(x*50+b*2)%300 ;
c=(a+3)%300;
setpixel (y+100,a+vpos,BLACK);
setpixel (y+100,c+vpos,BLACK);
}
}
}
for (y=1700;y<2400;y++)
{
a=(y-1700)/70 ;
for (x=0;x<30;x++)
{
setpixel (y+100,vpos+x*10+a,BLACK);
}
}
for (y=2400;y<3100;y++)
{
a=(y-2400)%70 ;
if (a==0)
{
for (x=0;x<300;x++)
{
setpixel ( y+100,x+vpos,BLACK);
}
}
}
}
void
color_squares( void )
{
int x,y,z;
/* color squares (Giorgio) (dont work after modifications 15/03/2000)
seems to use a different color coding scheme ..... 125 possible
color values in a byte ... */
z=0;
for (x=0;x<5;x++)
for (y=0;y<5;y++)
{
setsquare( 300*(x+1), 300+300*(y),200, 1+x,1+y,1+z);
setchar( 300*(x+1), 270+300*(y), '0' + x,3);
setchar( 40+300*(x+1), 270+300*(y), '0' + y,3);
setchar( 80+300*(x+1), 270+300*(y), '0' + z,3);
}
z=1;
for (x=0;x<5;x++)
for (y=0;y<5;y++)
{
setsquare( 1500+300*(x+1), 300+300*(y),200, 1+x,1+y,1+z);
setchar( 1500+300*(x+1), 270+300*(y), '0' + x,3);
setchar( 1540+300*(x+1), 270+300*(y), '0' + y,3);
setchar( 1580+300*(x+1), 270+300*(y), '0' + z,3);
}
z=2;
for (x=0;x<5;x++)
for (y=0;y<5;y++)
{
setsquare( 3000+300*(x+1), 300+300*(y),200, 1+x,1+y,1+z);
setchar( 3000+300*(x+1), 270+300*(y), '0' + x,3);
setchar( 3040+300*(x+1), 270+300*(y), '0' + y,3);
setchar( 3080+300*(x+1), 270+300*(y), '0' + z,3);
}
z=3;
for (x=0;x<5;x++)
for (y=0;y<5;y++)
{
setsquare( 300*(x+1), 1800+300*(y),200, 1+x,1+y,1+z);
setchar( 300*(x+1), 1770+300*(y), '0' + x,3);
setchar( 40+300*(x+1), 1770+300*(y), '0' + y,3);
setchar( 80+300*(x+1), 1770+300*(y), '0' + z,3);
}
z=4;
for (x=0;x<5;x++)
for (y=0;y<5;y++)
{
setsquare( 1500+300*(x+1), 1800+300*(y),200, 1+x,1+y,1+z);
setchar( 1500+300*(x+1), 1770+300*(y), '0' + x,3);
setchar( 1540+300*(x+1), 1770+300*(y), '0' + y,3);
setchar( 1580+300*(x+1), 1770+300*(y), '0' + z,3);
}
}