void
conicarc(int x, int y, int x0, int y0, int x1, int y1, int a, int b)
{
/* based on Bresenham, CACM, Feb 77, pp 102-3 */
/* by Chris Van Wyk */
/* capitalized vars are an internal reference frame */
long dotcount = 0;
int osize;
int xs, ys, xt, yt, Xs, Ys, qs, Xt, Yt, qt,
M1x, M1y, M2x, M2y, M3x, M3y,
Q, move, Xc, Yc;
int ox1, oy1;
long delta;
float xc, yc;
float radius, slope;
float xstep, ystep;
osize = size;
setsize(t_size(pstab[osize-1] / drawsize));
ox1 = x1;
oy1 = y1;
if (a != b) /* an arc of an ellipse; internally, will still think of circle */
if (a > b) {
xstep = (float)a / b;
ystep = 1;
radius = b;
} else {
xstep = 1;
ystep = (float)b / a;
radius = a;
}
else { /* a circular arc; radius is computed from center and first point */
xstep = ystep = 1;
radius = sqrt((float)(sqr(x0 - x) + sqr(y0 - y)));
}
xc = x0;
yc = y0;
/* now, use start and end point locations to figure out
the angle at which start and end happen; use these
angles with known radius to figure out where start
and end should be
*/
slope = atan2((double)(y0 - y), (double)(x0 - x) );
if (slope == 0.0 && x0 < x)
slope = 3.14159265;
x0 = x + radius * cos(slope) + 0.5;
y0 = y + radius * sin(slope) + 0.5;
slope = atan2((double)(y1 - y), (double)(x1 - x));
if (slope == 0.0 && x1 < x)
slope = 3.14159265;
x1 = x + radius * cos(slope) + 0.5;
y1 = y + radius * sin(slope) + 0.5;
/* step 2: translate to zero-centered circle */
xs = x0 - x;
ys = y0 - y;
xt = x1 - x;
yt = y1 - y;
/* step 3: normalize to first quadrant */
if (xs < 0)
if (ys < 0) {
Xs = abs(ys);
Ys = abs(xs);
qs = 3;
M1x = 0;
M1y = -1;
M2x = 1;
M2y = -1;
M3x = 1;
M3y = 0;
} else {
Xs = abs(xs);
Ys = abs(ys);
qs = 2;
M1x = -1;
M1y = 0;
M2x = -1;
M2y = -1;
M3x = 0;
M3y = -1;
}
else if (ys < 0) {
Xs = abs(xs);
Ys = abs(ys);
qs = 0;
M1x = 1;
M1y = 0;
M2x = 1;
M2y = 1;
M3x = 0;
M3y = 1;
} else {
Xs = abs(ys);
Ys = abs(xs);
qs = 1;
M1x = 0;
M1y = 1;
M2x = -1;
M2y = 1;
M3x = -1;
M3y = 0;
}
Xc = Xs;
Yc = Ys;
if (xt < 0)
if (yt < 0) {
Xt = abs(yt);
Yt = abs(xt);
qt = 3;
} else {
Xt = abs(xt);
Yt = abs(yt);
qt = 2;
}
else if (yt < 0) {
Xt = abs(xt);
Yt = abs(yt);
qt = 0;
} else {
Xt = abs(yt);
Yt = abs(xt);
qt = 1;
}
/* step 4: calculate number of quadrant crossings */
if (((4 + qt - qs)
% 4 == 0)
&& (Xt <= Xs)
&& (Yt >= Ys)
)
Q = 3;
else
Q = (4 + qt - qs) % 4 - 1;
/* step 5: calculate initial decision difference */
delta = sqr(Xs + 1)
+ sqr(Ys - 1)
-sqr(xs)
-sqr(ys);
/* here begins the work of drawing
we hope it ends here too */
while ((Q >= 0)
|| ((Q > -2)
&& ((Xt > Xc)
&& (Yt < Yc)
)
)
) {
if (dotcount++ % DX == 0)
putdot((int)xc, (int)yc);
if (Yc < 0.5) {
/* reinitialize */
Xs = Xc = 0;
Ys = Yc = sqrt((float)(sqr(xs) + sqr(ys)));
delta = sqr(Xs + 1) + sqr(Ys - 1) - sqr(xs) - sqr(ys);
Q--;
M1x = M3x;
M1y = M3y;
{
int T;
T = M2y;
M2y = M2x;
M2x = -T;
T = M3y;
M3y = M3x;
M3x = -T;
}
} else {
if (delta <= 0)
if (2 * delta + 2 * Yc - 1 <= 0)
move = 1;
else
move = 2;
else if (2 * delta - 2 * Xc - 1 <= 0)
move = 2;
else
move = 3;
switch (move) {
case 1:
Xc++;
delta += 2 * Xc + 1;
xc += M1x * xstep;
yc += M1y * ystep;
break;
case 2:
Xc++;
Yc--;
delta += 2 * Xc - 2 * Yc + 2;
xc += M2x * xstep;
yc += M2y * ystep;
break;
case 3:
Yc--;
delta -= 2 * Yc + 1;
xc += M3x * xstep;
yc += M3y * ystep;
break;
}
}
}
setsize(osize);
drawline((int)xc-ox1,(int)yc-oy1,".");
}
void fillpoly(short int *datas, int n, ColorP c) {
static int dots[SCREENHEIGHT][MAXPTS];
static int counters[SCREENHEIGHT];
short int x1, y1, x2, y2;
int i, j, k, dir = -2;
double step, curx;
// printf("fillpoly starting with n = %i dots\n", n);
if(n <= 2) {
//printf("Désolé Vincent, tu m'envoies une ligne ou un point là ;-)\n");
switch(n) {
case 0:
return;
case 1:
pixel(datas[0], datas[1], c);
return;
case 2:
line(datas[0], datas[1], datas[2], datas[3], c);
return;
}
}
// Reinit array counters
for(i = 0; i < SCREENHEIGHT; i++) {
counters[i] = 0;
}
// Drawing lines
x2 = datas[n * 2 - 2];
y2 = datas[n * 2 - 1];
for(i = 0; i < n; i++) {
x1 = x2;
y1 = y2;
x2 = datas[i * 2];
y2 = datas[i * 2 + 1];
// line(x1, y1, x2, y2, c);
// continue;
if(y1 == y2) {
// printf("Horizontal line. x1: %i, y1: %i, x2: %i, y2: %i\n", x1, y1, x2, y2);
if(!dir)
continue;
putdot(x1, y1);
dir = 0;
continue;
}
step = (double)(x2 - x1) / (y2 - y1);
// printf("x1: %i, y1 = %i, x2 = %i, y2 = %i, step: %f\n", x1, y1, x2, y2, step);
curx = x1;
if(y1 < y2) {
for(j = y1; j < y2; j++, curx += step) {
// printf("j = %i, curx = %f\n", j, curx);
putdot((int)(curx + 0.5), j);
}
if(dir == -1) {
// printf("Adding extra (%i, %i)\n", x1, y1);
putdot(x1, y1);
}
dir = 1;
} else {
for(j = y1; j > y2; j--, curx -= step) {
// printf("j = %i, curx = %f\n", j, curx);
putdot((int)(curx + 0.5), j);
}
if(dir == 1) {
// printf("Adding extra (%i, %i)\n", x1, y1);
putdot(x1, y1);
}
dir = -1;
}
}
x1 = x2;
y1 = y2;
x2 = datas[0];
y2 = datas[1];
if(((y1 < y2) && (dir == -1)) || ((y1 > y2) && (dir == 1)) || ((y1 == y2) && (dir == 0))) {
// printf("Adding final extra (%i, %i)\n", x1, y1);
putdot(x1, y1);
}
// NOTE: all counters should be even now. If not, this is a bad (C) thing :-P
// Sorting datas
for(i = 0; i < SCREENHEIGHT; i++) {
// Very bad sorting... but arrays are very small (0, 2 or 4), so it's no quite use...
for(j = 0; j < (counters[i] - 1); j++) {
for(k = 0; k < (counters[i] - 1); k++) {
if(dots[i][k] > dots[i][k + 1])
swap(dots[i][k], dots[i][k + 1]);
}
}
}
// Drawing.
for(i = 0; i < SCREENHEIGHT; i++) {
if(counters[i]) {
// printf("%i dots on line %i\n", counters[i], i);
for(j = 0; j < counters[i] - 1; j += 2) {
// printf("Drawing line (%i, %i)-%i\n", dots[i][j], dots[i][j + 1], i);
hline(dots[i][j], dots[i][j + 1], i, c);
#ifdef DEBUGGING_POLYS
if((!dots[i][j]) || !(dots[i][j + 1])) {
printf("fillpoly: BLARGH!\n");
exit(-1);
}
#endif
}
}
}
}
int genrmt(char *infile, char *outfile)
{
int i,j;
FILE *fp;
double x,t0,t1;
char *cbuf,*fext;
/* open file */
switch(seqmode) {
case SEQ_MOLPHY: fext=fext_molphy; break;
case SEQ_PAML: fext=fext_paml; break;
case SEQ_PAUP: fext=fext_paup; break;
case SEQ_PUZZLE: fext=fext_puzzle; break;
case SEQ_PHYML: fext=fext_phyml; break;
case SEQ_MT:
default: fext=fext_mt; break;
}
if(infile) {
fp=openfp(infile,fext,"r",&cbuf);
printf("\n# reading %s",cbuf);
} else {
fp=STDIN;
printf("\n# reading from stdin");
}
/* read file */
mm=nn=0;
switch(seqmode) {
case SEQ_MOLPHY:
datmat = fread_mat_lls(fp, &mm, &nn); break;
case SEQ_PAML:
datmat = fread_mat_lfh(fp, &mm, &nn); break;
case SEQ_PAUP:
datmat = fread_mat_paup(fp, &mm, &nn); break;
case SEQ_PUZZLE:
datmat = fread_mat_puzzle(fp, &mm, &nn); break;
case SEQ_PHYML:
datmat = fread_mat_phyml(fp, &mm, &nn); break;
case SEQ_MT:
default:
datmat = fread_mat(fp, &mm, &nn); break;
}
if(infile) {fclose(fp); FREE(cbuf);}
printf("\n# M:%d N:%d",mm,nn);
/* allocating buffers */
datvec=new_vec(mm);
bn=new_ivec(kk); rr1=new_vec(kk);
/* calculate the log-likelihoods */
for(i=0;i<mm;i++) {
x=0; for(j=0;j<nn;j++) x+=datmat[i][j];
datvec[i]=x;
}
/* calculate scales */
for(i=0;i<kk;i++) {
bn[i]=(int)(rr[i]*nn); /* sample size for bootstrap */
rr1[i]=(double)bn[i]/nn; /* recalculate rr for integer adjustment */
}
/* open out file */
if(outfile) {
/* vt ascii write to file */
fp=openfp(outfile,fext_vt,"w",&cbuf);
printf("\n# writing %s",cbuf);
fwrite_vec(fp,datvec,mm);
fclose(fp); FREE(cbuf);
/* rmt binary write to file */
fp=openfp(outfile,fext_rmt,"wb",&cbuf);
printf("\n# writing %s",cbuf);
fwrite_bvec(fp,datvec,mm);
fwrite_bvec(fp,rr1,kk);
fwrite_bivec(fp,bb,kk);
fwrite_bi(fp,kk);
} else {
/* rmt ascii write to stdout */
printf("\n# writing to stdout");
printf("\n# OBS:\n"); write_vec(datvec,mm);
printf("\n# R:\n"); write_vec(rr1,kk);
printf("\n# B:\n"); write_ivec(bb,kk);
printf("\n# RMAT:\n");
printf("%d\n",kk);
}
/* generating the replicates by resampling*/
for(i=j=0;i<kk;i++) j+=bb[i];
printf("\n# start generating total %d replicates for %d items",j,mm);
fflush(STDOUT);
t0=get_time();
for(i=0;i<kk;i++) {
repmat=new_lmat(mm,bb[i]);
scaleboot(datmat,repmat,mm,nn,bn[i],bb[i]);
if(outfile) {
fwrite_bmat(fp,repmat,mm,bb[i]);
putdot();
} else {
printf("\n## RMAT[%d]:\n",i); write_mat(repmat,mm,bb[i]);
}
free_lmat(repmat,mm);
}
t1=get_time();
printf("\n# time elapsed for bootstrap t=%g sec",t1-t0);
if(outfile) {
fclose(fp); FREE(cbuf);
}
/* freeing buffers */
free_vec(bn); free_vec(rr1); free_vec(datvec); free_mat(datmat);
return 0;
}
int main( int argc, char *argv[]){
if(argc < 3) {
printf("Usage: %s filename.img] Size x.x MB\n", argv[0]);
return 1;
}
int i, j;
unsigned long last_cnt;
strcpy(drv_type,"hd");
strcpy(filename,argv[1]);
cylinders = (atof(argv[2])*2.1)/1024/1024;// << 1);
printf("creating FAT12 image size = %3.2f MB's\n",cylinders/2);
// print start string
//printf(strtstr);
//do {
// printf("Make Floppy or Hard Drive image? (fd/hd) [fd]: ");
// gets(drv_type);
// if (!strlen(drv_type)) { strcpy(drv_type, "fd"); break; }
//} while (strcmp(drv_type, "fd") && strcmp(drv_type, "hd"));
//printf(" As filename [%c.img]: ", (drv_type[0] == 'h') ? 'c' : 'a');
//gets(filename);
//if (!strlen(filename)) strcpy(filename, (drv_type[0] == 'h') ? "c.img" : "a.img");
//if (drv_type[0] == 'h') {
// do {
// printf(" Size (meg) (1 - 1024) [10]: ");
// gets(strbuff);
// if (!strlen(strbuff))
// i = 10;
// else
// i = atoi(strbuff);
// } while ((i < 1) || (i > 1024));
//cylinders = (10 << 1); // very close at 16 heads and 63 spt
heads = 16;
spt = 63;
fat_size = 12;
//} else {
// do {
// printf(" Sectors per track (8, 9, 15, 18, 36) [18]: ");
// gets(strbuff);
// if (!strlen(strbuff))
// i = 18;
// else
// i = atoi(strbuff);
// } while ((i != 8) && (i != 9) && (i != 15) && (i != 18) && (i != 36));
// if (i == 36) spclust = 2;
// spt = i;
// do {
// printf(" Heads: (1, 2) [2]: ");
// gets(strbuff);
// if (!strlen(strbuff))
// i = 2;
// else
// i = atoi(strbuff);
// } while ((i != 1) && (i != 2));
// heads = i;
// do {
// printf(" Cylinders: (40, 80) [80]: ");
// gets(strbuff);
// if (!strlen(strbuff))
// i = 80;
// else
// i = atoi(strbuff);
// } while ((i != 40) && (i != 80));
// cylinders = i;
// fat_size = 12;
//}
sectors = (cylinders * heads * spt);
//do {
// printf(" Sectors per Cluster [% 2i]: ", spclust);
// gets(strbuff);
// if (!strlen(strbuff))
// i = spclust;
// else
// i = atoi(strbuff);
//} while (i > 255);
//spclust = i;
//do {
// printf(" Number of FAT's [2]: ");
// gets(strbuff);
// if (!strlen(strbuff))
// fats = 2;
// else
// fats = atoi(strbuff);
//} while (fats > 2);
//
//do {
// printf(" FAT Size: [%02i]: ", fat_size);
// gets(strbuff);
// if (!strlen(strbuff))
// i = fat_size;
// else
// i = atoi(strbuff);
//} while ((i != 12) && (i != 16) && (i != 32));
//fat_size = i;
switch (fat_size) {
case 12:
//if ((sectors / (unsigned long) spclust) > 4086L) {
// printf(" *** Illegal Size disk with FAT 12 *** \n");
// exit(0x12);
//}
spfat = (unsigned short) ((unsigned short)((float) sectors * 1.5) / (512 * spclust)) + 1;
// actual count bytes on last fat sector needed as zeros (???)
last_cnt = ((sectors - ((fats * spfat) + 17)) / spclust);
last_cnt = ((unsigned long) ((float) last_cnt * 1.5) % 512);
break;
case 16:
if ((sectors / (unsigned long) spclust) > 65526L) {
printf(" *** Illegal Size disk with FAT 16 *** \n");
exit(0x12);
}
spfat = (unsigned short) ((sectors << 1) / (512 * spclust)) + 1;
// actual count bytes on last fat sector needed as zeros (???)
last_cnt = ((sectors - ((fats * spfat) + 17)) / spclust);
last_cnt = ((unsigned long) (last_cnt << 1) % 512);
break;
default:
spfat = (unsigned short) ((sectors << 2) / (512 * spclust)) + 1;
// actual count bytes on last fat sector needed as zeros (???)
last_cnt = ((sectors - ((fats * spfat) + 17)) / spclust);
last_cnt = ((unsigned long) (last_cnt << 2) % 512);
}
//printf("\n Creating file: [%s]"
// "\n Cylinders: %i"
// "\n Sides: %i"
// "\n Sectors/Track: %i"
// "\n Total Sectors: %lu"
// "\n Size: %3.2f (megs)"
// "\n Sectors/Cluster: %i"
// "\n FAT's: %i"
// "\n Sectors/FAT: %i"
// "\n FAT size: %i",
// filename, cylinders, heads, spt, sectors,
// (float) ((float) sectors / 2000.0), spclust, fats, spfat, fat_size);
// create BPB
bpb.jmps[0] = 0xEB; bpb.jmps[1] = 0x3C;
bpb.nop = 0x90;
memcpy(bpb.oemname, "MKDOSFS ", 8); // char oemname[8]; // OEM name
bpb.nBytesPerSec = 512; // unsigned short nBytesPerSec; // Bytes per sector
bpb.nSecPerClust = spclust; // unsigned char nSecPerClust; // Sectors per cluster
bpb.nSecRes = 1; // unsigned short nSecRes; // Sectors reserved for Boot Record
bpb.nFATs = fats; // unsigned char nFATs; // Number of FATs
bpb.nRootEnts = 224; // unsigned short nRootEnts; // Max Root Directory Entries allowed
if (sectors < 65536) { // unsigned short nSecs; // Number of Logical Sectors
bpb.nSecs = (unsigned short) sectors;
bpb.nSecsExt = 0; // unsigned long nSecsExt; // This value used when there are more
} else {
bpb.nSecs = 0;
bpb.nSecsExt = sectors; // unsigned long nSecsExt; // This value used when there are more
}
bpb.mDesc = 0xF9; // unsigned char mDesc; // Medium Descriptor Byte (we have it set as floppy 1.44)
bpb.nSecPerFat = spfat; // unsigned short nSecPerFat; // Sectors per FAT
bpb.nSecPerTrack = spt; // unsigned short nSecPerTrack; // Sectors per Track
bpb.nHeads = heads; // unsigned short nHeads; // Number of Heads
bpb.nSecHidden = 0; // unsigned long nSecHidden; // Number of Hidden Sectors
bpb.DriveNum = 0; // unsigned char DriveNum; // Physical drive number
bpb.nResByte = 0; // unsigned char nResByte; // Reserved (we use for FAT type (12- 16-bit)
bpb.sig = 0x29; // unsigned char sig; // Signature for Extended Boot Record
bpb.SerNum = 0; // unsigned long SerNum; // Volume Serial Number
memcpy(bpb.VolName, "NO LABEL ", 11); // char VolName[11]; // Volume Label
sprintf(strbuff, "FAT%2i ", fat_size);
memcpy(bpb.FSType, strbuff, 8); // char FSType[8]; // File system type
memset(bpb.filler, 0, 448); // first, clear it out
memcpy(bpb.filler, boot_code, sizeof(boot_code)); // then place code
memcpy(bpb.filler+sizeof(boot_code), boot_data, sizeof(boot_data)); // then place data
bpb.boot_sig = 0xAA55;
if ((fp = fopen(filename, "wb")) == NULL) {
printf("\nError creating file [%s]", filename);
return 0x01;
}
printf("\n\nWorking[");
// write the BPB
putdot();
write_sectors(fp, &bpb, 1);
sectors--;
// write the FAT(s)
for (i=0; i<fats; i++) {
memset(buffer, 0, 512);
switch (fat_size) {
case 32:
buffer[7] = 0xFF;
buffer[6] = 0xFF;
buffer[5] = 0xFF;
buffer[4] = 0xFF;
case 16:
buffer[3] = 0xFF;
case 12:
buffer[0] = 0xF9;
buffer[1] = 0xFF;
buffer[2] = 0xFF;
}
putdot();
write_sectors(fp, &buffer, 1);
sectors--;
memset(buffer, 0, 512);
for (j=0; j<spfat-2; j++) {
putdot();
write_sectors(fp, &buffer, 1);
sectors--;
}
// write last sector of FAT filling in unused entries
// (last_cnt isn't exact, but it is pretty close. I just
// didn't want to spend the time to get it exact :)
memset(buffer, 0, (unsigned short) last_cnt);
memset(buffer + last_cnt, 0xFF, (unsigned short) (512-last_cnt));
putdot();
write_sectors(fp, &buffer, 1);
sectors--;
}
// write the root
memset(buffer, 0, 512);
for (i=0; i<14; i++) {
putdot();
write_sectors(fp, &buffer, 1);
sectors--;
}
// write data area
memset(buffer, 0, 512);
while (sectors--) {
putdot();
write_sectors(fp, &buffer, 1);
}
printf("]Done");
// close the file
fclose(fp);
return 0x00;
}
