toCargs *readArgs(int argc, char *argv[]){
toCargs *pars = new toCargs();
int start = 1;
while (start<argc){
if(!strcmp(argv[start],"-g")){
pars->data = readmatrix(argv[start+1]);
}
else if(!strcmp(argv[start],"-LD")){
pars->LD = atoi( argv[start+1]);
}
else if(!strcmp(argv[start],"-back")){
pars->back =to_int ( argv[start+1],0,0);
}
else if(!strcmp(argv[start],"-threshold")){
pars->prune_val =to_double(std::string(argv[start+1]));
}
else if(!strcmp(argv[start],"-filename")){
pars->data_filename = std::string(argv[start+1]);
}
else if(!strcmp(argv[start],"-snps")){
pars->usedSnps_filename = std::string(argv[start+1]);
}
else{
printf("\t->Command line option not recognized: \t%s\n",argv[start]);
exit(0);
}
start+=2;
}
return pars;
}
int main( int argc, char *argv[]){
int nobs;
if ( 3!=argc){ fputs("Usage: wLR nobs filename\n",stderr); return EXIT_FAILURE;}
FILE * fp = fopen(argv[2],"r");
sscanf(argv[1],"%d",&nobs);
real_t * vars = readmatrix(fp,nobs,3);
fputs("* Standard linear regression.\n",stdout);
real_t * res = linearRegression(vars+nobs,vars+2*nobs,NULL,nobs,NULL);
fprintf(stdout,"Slope = %f\nConstant = %f\ndiffLS = %f\n",res[0],res[1],res[2]);
fputs("* Weighted linear regression, using weights from file.\n",stdout);
res = wLinearRegression(vars,vars+nobs,vars+2*nobs,NULL,nobs,res);
fprintf(stdout,"Slope = %f\nConstant = %f\ndiffLS = %f\n",res[0],res[1],res[2]);
fputs("* Iteratively reWeighted Least Squares, Cauchy.\n",stdout);
res = iwlsLinearRegression(cauchy,vars+nobs,vars+2*nobs,NULL,100,nobs,res);
fprintf(stdout,"Slope = %f\nConstant = %f\ndiffLS = %f\n",res[0],res[1],res[2]);
fputs("* Iteratively reWeighted Least Squares, Tukey biweight.\n",stdout);
res = iwlsLinearRegression(tukey_biweight,vars+nobs,vars+2*nobs,NULL,100,nobs,res);
fprintf(stdout,"Slope = %f\nConstant = %f\ndiffLS = %f\n",res[0],res[1],res[2]);
return EXIT_SUCCESS;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
if (nrhs < 1)
{
mexErrMsgTxt("filename must be given");
return;
}
long buflen = (mxGetM(prhs[0]) * mxGetN(prhs[0]) * sizeof(mxChar)) + 8;
char* filename = new char[buflen];
mxGetString(prhs[0], filename, buflen);
FILE* fid = fopen(filename, "r");
if (fid != NULL) {
plhs[0] = readmatrix(fid);
fclose(fid);
} else {
mexPrintf("Error opening argument list file %s \n", filename);
mexErrMsgTxt("");
return;
}
delete[] filename;
}
int main(){
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
int source, treecost;
readmatrix();
printf("\nEnter the Source : ");
scanf("%d",&source);
treecost =spanningtree(source);
display(treecost);
return 0;
}
int generate_trial(const char *filename, int verbose, int output_on_file, char *outfilename, double **output, uint *index, double srate, double dt)
{
char mytext[500];
double **parsed_data;
double T; // Total duration [s].
uint Ni; // Partial duration [points].
uint N; // Size of the output waveform (i.e. N = T / dt).
FILE *fp;
size_t cols, nlines;
uint current_line;
uint i, return_code;
//--------------------------------------------------------------------------------------
// Data structure containing the input file is defined and created here.
parsed_data = (double **) calloc(MAXROWS, sizeof(double *));
if (parsed_data == NULL) { error("Unable to allocate memory for <parsed_data> !", verbose); return -1; }
for (i=0; i<MAXROWS; i++) {
parsed_data[i] = (double *) calloc(MAXCOLS, sizeof(double));
if (parsed_data[i] == NULL) { error("Unable to allocate memory for <parsed_data[i]> !", verbose); return -1; }
}
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
// The input-file parsing routine is invoked here..
if (readmatrix(filename, parsed_data, &nlines, &cols) == -1) {
error("impossible to proceed.", verbose); return -1; }
sprintf(mytext,"[%s] acquired correctly: %d lines, %d columns", filename, (int) nlines, (int) cols); msg(mytext, verbose);
if (nlines == 0) { warning("No stimulus to be parsed: file empty!", verbose); return -1; }
/*
printf("The parsed file was:\n");
for (i=0; i<nlines; i++) {
for (j=0; j<cols+2; j++)
printf("%f ", parsed_data[i][j]);
printf("\n");
} // end for()
*/
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
// Data structure containing the output file is defined and created here.
T = how_long_lasts_trial(parsed_data, nlines);
if (T <= 0) { error("Zero trial duration !", verbose); return -1; }
sprintf(mytext, "Total time: %.2f s @ %.1f Hz", T, srate); msg(mytext, verbose);
N = (uint) ceill(T * srate) + nlines - 1;
(*output) = (double *) calloc(N, sizeof(double)); // Please note: "c"-alloc is indeed required here!
if ((*output) == NULL) { error("Unable to allocate memory for <output> !", verbose); return -1; }
//--------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------
// Let's start managing the input file..
current_line = 0; // Starting from the first entry
(*index) = 0; // Index of the output data structure "output" is set to "0".
while (current_line < nlines) {
if (parsed_data[current_line][CODE] > 0) {
Ni = (uint) ceill(parsed_data[current_line][DURATION] * srate);
if (((*index)+Ni) > N) { fprintf(stderr, "%d > %d\n", (*index)+Ni, N); error("Out of range in <output> !", verbose); return -1; }
return_code = simple_waveform(parsed_data[current_line], (*output), index, Ni, srate, dt, verbose);
if (return_code == -1) { error("simple_waveform returned -1", verbose); return -1;}
current_line++;
}
else
{
i = composite_waveform(parsed_data, current_line, (*output), index, N, srate, dt, verbose);
if (i == -1) { error("composite_waveform returned -1", verbose); return -1;}
current_line += i;
}
} // end while()
//--------------------------------------------------------------------------------------
if (output_on_file) {
fp = fopen(outfilename, "w");
for (i=0; i<(*index); i++)
fprintf(fp, "%f %f\n", i*dt, (*output)[i]);
}
//--------------------------------------------------------------------------------------
// Allocated memory is released here.
for (i=0; i<MAXROWS; i++) free(parsed_data[i]);
free(parsed_data);
//free((*output)); // NOT HERE FOR THIS VERSION OF MULTICHANNEL!!
//--------------------------------------------------------------------------------------
return 0;
}
void loadprojectfile(unsigned char *file)
{
unsigned char *f=file;
scenelist=NULL;
vector3 xpse;
float phi;
char floatbytes=readbyte(&file);
material *pt;
texture *t;
//////////////// TEXTURE LOAD ////////////////////
unsigned char texnum=readbyte(&file);
int aa;
for (aa=1; aa<=texnum; aa++)
{
texture *t=new texture;
inittexture(*t);
t->ID=readbyte(&file); //texture id
t->next=texturelist;
texturelist=t;
char cmdcnt=readbyte(&file); //command count
for (int x=0;x<cmdcnt;x++)
{
texturecommand cmd;
memcpy(&cmd,file,9);
file+=9;
if (cmd.commandnumber==DD_text)
{
byte bb=readbyte(&file);
memcpy(t->texts[x].text,file,bb);
file+=bb; //text
}
performcommand(*t,cmd);
//precalc((float)(aa-1)/(float)(texnum-1)+1.0f/float(texnum)*(float)x/(float)cmdcnt);
precalc((float)(aa-1)/(float)(texnum)+1.0f/(float)(texnum)*(float)x/(float)cmdcnt);
}
}
/////////////// MATERIAL LOAD ////////////////////
texnum=readbyte(&file);
for (aa=1; aa<=texnum; aa++)
{
material *m=new material;
m->next=materiallist;
materiallist=m;
m->texture=readbyte(&file);
m->layer=readbyte(&file);
m->alphatexture=readbyte(&file);
m->alphalayer=readbyte(&file);
m->alphamode=readbyte(&file);
m->number=readbyte(&file);
creatematerial(m);
}
byte scenenum=readbyte(&file);
for (int ar=1; ar<=scenenum; ar++)
{
scene *Scene=newscene();
Scene->number=readbyte(&file);
/////////////////// ENVIRONMENT LOAD ////////////////////
Scene->fog=readbyte(&file);
if (Scene->fog)
{
Scene->fogcol[0]=(float)readbyte(&file)/255.0f;
Scene->fogcol[1]=(float)readbyte(&file)/255.0f;
Scene->fogcol[2]=(float)readbyte(&file)/255.0f;
Scene->fogdensity=readfloat(&file,floatbytes);
}
int lightnum=readbyte(&file);
for (int x=0; x<lightnum; x++)
{
int ID=readbyte(&file);
int type=readbyte(&file);
Scene->lights[x].turnedon=true;
Scene->lights[x].position[3]=0;
Scene->lights[x].ambient[0]=(float)readbyte(&file)/255.0f;
Scene->lights[x].ambient[1]=(float)readbyte(&file)/255.0f;
Scene->lights[x].ambient[2]=(float)readbyte(&file)/255.0f;
Scene->lights[x].color[0]=(float)readbyte(&file)/255.0f;
Scene->lights[x].color[1]=(float)readbyte(&file)/255.0f;
Scene->lights[x].color[2]=(float)readbyte(&file)/255.0f;
Scene->lights[x].position[0]=readfloat(&file,floatbytes);
Scene->lights[x].position[1]=readfloat(&file,floatbytes);
Scene->lights[x].position[2]=readfloat(&file,floatbytes);
if (type>=1)
{
Scene->lights[x].position[3]=1;
Scene->lights[x].c_att=readfloat(&file,floatbytes);
Scene->lights[x].l_att=readfloat(&file,floatbytes);
Scene->lights[x].q_att=readfloat(&file,floatbytes);
}
if (type==2)
{
Scene->lights[x].spot_direction[0]=readfloat(&file,floatbytes);
Scene->lights[x].spot_direction[1]=readfloat(&file,floatbytes);
Scene->lights[x].spot_direction[2]=readfloat(&file,floatbytes);
Scene->lights[x].spot_exponent=readfloat(&file,floatbytes);
Scene->lights[x].spot_cutoff=readfloat(&file,floatbytes);
}
else
Scene->lights[x].spot_cutoff=180.0;
}
/////////////////// OBJECT LOAD /////////////////////
int objnum=readword(&file);
for (int aa=1;aa<=objnum;aa++)
{
addobject(*Scene);
tminimalobjdata objdata;
memcpy(&objdata,file,sizeof(objdata));
int current=Scene->objectnum-1;
Scene->objects[current].data=objdata;
file+=4;
Scene->objects[current].number=readword(&file);
Scene->objects[current].parent=readword(&file);
if (objdata.textured || objdata.primitive==aDDict_map) Scene->objects[current].texture=readbyte(&file);
if (objdata.red) Scene->objects[current].color[0]=(float)readbyte(&file)/255.0f;
if (objdata.green) Scene->objects[current].color[1]=(float)readbyte(&file)/255.0f;
if (objdata.blue) Scene->objects[current].color[2]=(float)readbyte(&file)/255.0f;
if (objdata.alpha) Scene->objects[current].color[3]=(float)readbyte(&file)/255.0f;
if (objdata.alphamap1set) readbyte(&file);
if (objdata.material2set) Scene->objects[current].envmap=readbyte(&file);
if (objdata.texxset || objdata.primitive==aDDict_map) Scene->objects[current].texxscale=readbyte(&file);
if (objdata.texyset || objdata.primitive==aDDict_map) Scene->objects[current].texyscale=readbyte(&file);
if (objdata.texoffxset || objdata.primitive==aDDict_map) Scene->objects[current].texxoffset=readbyte(&file);
if (objdata.texoffyset || objdata.primitive==aDDict_map) Scene->objects[current].texyoffset=readbyte(&file);
switch (objdata.primitive)
{
case aDDict_grid:
case aDDict_hasab:
case aDDict_cone:
case aDDict_sphere:
{
Scene->objects[current].params[0]=readbyte(&file);
Scene->objects[current].params[1]=readbyte(&file);
break;
}
case aDDict_arc:
{
Scene->objects[current].params[0]=readbyte(&file);
Scene->objects[current].params[1]=readword(&file);
break;
}
case aDDict_line:
{
Scene->objects[current].params[0]=readbyte(&file);
break;
}
case aDDict_loft:
{
Scene->objects[current].params[0]=readword(&file);
Scene->objects[current].params[1]=readword(&file);
Scene->objects[current].params[2]=(int)Scene->objects;
Scene->objects[current].params[3]=Scene->objectnum;
break;
}
case aDDict_map:
{
texnum=readbyte(&file);
Scene->objects[current].envmap=texnum;
switch (texnum)
{
case 0:
{
xpse.x=readfloat(&file,floatbytes);
xpse.y=readfloat(&file,floatbytes);
xpse.z=readfloat(&file,floatbytes);
break;
}
case 1:
{
xpse.x=readfloat(&file,floatbytes);
xpse.y=readfloat(&file,floatbytes);
xpse.z=readfloat(&file,floatbytes);
break;
}
case 2:
{
xpse.x=readfloat(&file,floatbytes);
xpse.y=readfloat(&file,floatbytes);
xpse.z=readfloat(&file,floatbytes);
phi=readfloat(&file,floatbytes);
break;
}
}
pt=findmaterial(Scene->objects[current].texture);
t=findtexture(pt->texture);
memcpy(maptexture,t->layers[pt->layer],256*256*4);
}
case aDDict_blur:
case aDDict_linearsubdivision:
case aDDict_butterfly:
{
if (objdata.primitive!=aDDict_map)
texnum=readbyte(&file);
Scene->objects[current].params[1]=(int)readselection(&file);
for (selection *s=(selection*)Scene->objects[current].params[1];s;s=s->next)
{
switch (Scene->objects[current].data.primitive)
{
case aDDict_map:
{
object *o=searchobjectbynumber(Scene->objects,Scene->objectnum,s->selected);
obj_counttexturecoordinates( o,Scene->objects[current].texxscale,Scene->objects[current].texyscale,
Scene->objects[current].texxoffset,
Scene->objects[current].texyoffset,
!Scene->objects[current].data.swaptexturexy,
Scene->objects[current].data.inverttexx,
Scene->objects[current].data.inverttexy);
switch (Scene->objects[current].envmap)
{
case 0:
{
matrix s;
for (int a=0; a<o->vertexnum; a++)
{
float p=getmappixel(o->vertices[a].t,Scene->objects[current].data.alphachannel,
Scene->objects[current].data.normalsinverted);
m_xpose(p*xpse.x,p*xpse.y,p*xpse.z,s);
m_xformd(s,o->vertices[a].base,o->vertices[a].d);
}
break;
}
case 1:
{
matrix s;
for (int a=0; a<o->vertexnum; a++)
{
float p=getmappixel(o->vertices[a].t,Scene->objects[current].data.alphachannel,
Scene->objects[current].data.normalsinverted);
m_scale(p*(xpse.x-1)+1,p*(xpse.y-1)+1,p*(xpse.z-1)+1,s);
m_xformd(s,o->vertices[a].base,o->vertices[a].d);
}
break;
}
case 2:
{
matrix s;
for (int a=0; a<o->vertexnum; a++)
{
float p=getmappixel(o->vertices[a].t,Scene->objects[current].data.alphachannel,
Scene->objects[current].data.normalsinverted);
m_rotate(xpse.x,xpse.y,xpse.z,p*phi,s);
m_xformd(s,o->vertices[a].base,o->vertices[a].d);
}
break;
}
}
for (int x=0; x<o->vertexnum; x++)
{
o->vertices[x].base=o->vertices[x].d;
o->vertices[x].t=o->vertices[x].dt;
}
obj_counttexturecoordinates(o, o->texxscale, o->texyscale, o->texxoffset, o->texyoffset, o->data.swaptexturexy, o->data.inverttexx, o->data.inverttexy);
obj_generatenormals(o);
obj_transform(o,o->xformmatrix);
break;
}
case aDDict_blur:
case aDDict_linearsubdivision:
case aDDict_butterfly:
{
for (selection *s=(selection*)Scene->objects[current].params[1];s;s=s->next)
{
object *o=searchobjectbynumber(Scene->objects,Scene->objectnum,s->selected);
for (int x=0; x<texnum; x++)
{
if (objdata.primitive==aDDict_blur) meshblur(o);
else butterflysubdivision(o,objdata.primitive==aDDict_linearsubdivision);
}
}
break;
}
}
}
break;
}
case aDDict_boolean:
{
char function=readbyte(&file);
int baseobj=readword(&file);
int brush=readword(&file);
//object *baseobject=searchobjectbynumber(Scene->objects,Scene->objectnum,baseobj);
//object *brushobject=searchobjectbynumber(Scene->objects,Scene->objectnum,brush);
matrix difference;//,m;
readmatrix(&file, floatbytes, difference);
//memcpy(m,brushobject->xformmatrix,sizeof(matrix));
//matrix m2;
//m_mult(baseobject->xformmatrix,difference,m2);
//obj_transform(brushobject,m2);
//obj_boolean(baseobject,brushobject,function);
//memcpy(brushobject->xformmatrix,m,sizeof(matrix));
//obj_transform(brushobject,brushobject->xformmatrix);
break;
}
}
if (objdata.primitive==aDDict_hasab) Scene->objects[current].params[2]=readbyte(&file);
switch (objdata.primitive)
{
case aDDict_box:
case aDDict_icosaeder:
case aDDict_dodecaeder:
case aDDict_sphere:
case aDDict_hasab:
case aDDict_cone:
case aDDict_arc:
case aDDict_loft:
case aDDict_line:
case aDDict_grid:
case aDDict_clone:
{
readmatrix(&file, floatbytes, Scene->objects[current].xformmatrix);
if (objdata.primitive==aDDict_clone)
{
Scene->objects[current].params[0]=(int)readselection(&file);
Scene->objects[current].params[1]=(int)Scene->objects;
Scene->objects[current].params[2]=Scene->objectnum;
}
obj_createprimitive(&Scene->objects[current],Scene->objects[current].data.primitive,Scene->objects[current].params[0],Scene->objects[current].params[1],Scene->objects[current].params[2],Scene->objects[current].params[3]);
obj_transform(&Scene->objects[current],Scene->objects[current].xformmatrix);
if (Scene->objects[current].data.primitive!=aDDict_clone)
obj_counttexturecoordinates(&Scene->objects[current], Scene->objects[current].texxscale, Scene->objects[current].texyscale, Scene->objects[current].texxoffset, Scene->objects[current].texyoffset, Scene->objects[current].data.swaptexturexy, Scene->objects[current].data.inverttexx, Scene->objects[current].data.inverttexy);
obj_generatenormals(&Scene->objects[current]);
for (int x=0; x<Scene->objects[current].polygonnum; x++)
{
Scene->objects[current].polygons[x].color.x=Scene->objects[current].color[0];
Scene->objects[current].polygons[x].color.y=Scene->objects[current].color[1];
Scene->objects[current].polygons[x].color.z=Scene->objects[current].color[2];
Scene->objects[current].polygons[x].color.w=Scene->objects[current].color[3];
if (Scene->objects[current].data.shading!=aDDict_default) Scene->objects[current].polygons[x].shading=Scene->objects[current].data.shading;
}
if (Scene->objects[current].data.textured && Scene->objects[current].data.primitive!=aDDict_clone)
{
material *m=findmaterial(Scene->objects[current].texture);
if (m!=NULL)
for (int x=0; x<Scene->objects[current].polygonnum; x++)
{
Scene->objects[current].polygons[x].texturehandle=m->handle;
}
}
if (Scene->objects[current].data.material2set && Scene->objects[current].data.primitive!=aDDict_clone)
{
material *m=findmaterial(Scene->objects[current].envmap);
if (m!=NULL)
for (int x=0; x<Scene->objects[current].polygonnum; x++)
{
Scene->objects[current].polygons[x].envmaphandle=m->handle;
}
}
break;
}
}
}
//////////////////////////// CAMERA LOAD ////////////////////////////////
//MessageBox( 0, "camload", "HelloWorld", MB_OK );
byte camnum=readbyte(&file);
for (aa=1; aa<=camnum; aa++)
{
camera *c=new camera;
memset(c,0,sizeof(camera));
c->next=Scene->cameras;
Scene->cameras=c;
c->number=readbyte(&file); //camera ID
c->up.y=-1;
byte keyframenum=readbyte(&file);
if (keyframenum)
{
//c->eyex.numkey=keyframenum;
//c->eyex.keys=new KEY[keyframenum];
c->eyex=new CTrack(keyframenum);
c->eyey=new CTrack(keyframenum);
c->eyez=new CTrack(keyframenum);
c->trgx=new CTrack(keyframenum);
c->trgy=new CTrack(keyframenum);
c->trgz=new CTrack(keyframenum);
c->fovt=new CTrack(keyframenum);
c->rollt=new CTrack(keyframenum);
/*c->eyey.numkey=keyframenum;
c->eyey.keys=new KEY[keyframenum];
c->eyez.numkey=keyframenum;
c->eyez.keys=new KEY[keyframenum];
c->trgx.numkey=keyframenum;
c->trgx.keys=new KEY[keyframenum];
c->trgy.numkey=keyframenum;
c->trgy.keys=new KEY[keyframenum];
c->trgz.numkey=keyframenum;
c->trgz.keys=new KEY[keyframenum];
c->fovt.numkey=keyframenum;
c->fovt.keys=new KEY[keyframenum];
c->rollt.numkey=keyframenum;
c->rollt.keys=new KEY[keyframenum];*/
int frame=readword(&file); //frame
int fov=readbyte(&file); //fov
int roll=readword(&file); //roll
float eyex=readfloat(&file,floatbytes); //eyex
float eyey=readfloat(&file,floatbytes); //eyey
float eyez=readfloat(&file,floatbytes); //eyez
float trgx=readfloat(&file,floatbytes); //trgx
float trgy=readfloat(&file,floatbytes); //trgy
float trgz=readfloat(&file,floatbytes); //trgz
setkeydata(c->eyex->keys,frame,eyex);
setkeydata(c->eyey->keys,frame,eyey);
setkeydata(c->eyez->keys,frame,eyez);
setkeydata(c->trgx->keys,frame,trgx);
setkeydata(c->trgy->keys,frame,trgy);
setkeydata(c->trgz->keys,frame,trgz);
setkeydata(c->fovt->keys,frame,(float)fov);
setkeydata(c->rollt->keys,frame,(float)roll);
/*c->eyex.keys[0].data=eyex;
c->eyex.keys[0].frame=frame;
c->eyey.keys[0].data=eyey;
c->eyey.keys[0].frame=frame;
c->eyez.keys[0].data=eyez;
c->eyez.keys[0].frame=frame;
c->trgx.keys[0].data=trgx;
c->trgx.keys[0].frame=frame;
c->trgy.keys[0].data=trgy;
c->trgy.keys[0].frame=frame;
c->trgz.keys[0].data=trgz;
c->trgz.keys[0].frame=frame;
c->fovt.keys[0].data=(float)fov;
c->fovt.keys[0].frame=frame;
c->rollt.keys[0].data=(float)roll;
c->rollt.keys[0].frame=frame;*/
for (int x=1; x<keyframenum; x++)
{
frame=readword(&file); //frame
camfield cf;
memset(&cf,0,sizeof(cf));
memcpy(&cf,file,1); //mask
file+=1;
if (cf.fovwritten) fov=readbyte(&file);
if (cf.rollwritten) roll=readword(&file);
if (cf.eyexwritten) eyex=readfloat(&file,floatbytes);
if (cf.eyeywritten) eyey=readfloat(&file,floatbytes);
if (cf.eyezwritten) eyez=readfloat(&file,floatbytes);
if (cf.targetxwritten) trgx=readfloat(&file,floatbytes);
if (cf.targetywritten) trgy=readfloat(&file,floatbytes);
if (cf.targetzwritten) trgz=readfloat(&file,floatbytes);
/*c->eyex.keys[x].data=eyex;
c->eyex.keys[x].frame=frame;
c->eyey.keys[x].data=eyey;
c->eyey.keys[x].frame=frame;
c->eyez.keys[x].data=eyez;
c->eyez.keys[x].frame=frame;
c->trgx.keys[x].data=trgx;
c->trgx.keys[x].frame=frame;
c->trgy.keys[x].data=trgy;
c->trgy.keys[x].frame=frame;
c->trgz.keys[x].data=trgz;
c->trgz.keys[x].frame=frame;
c->fovt.keys[x].data=(float)fov;
c->fovt.keys[x].frame=frame;
c->rollt.keys[x].data=(float)roll;
c->rollt.keys[x].frame=frame;*/
setkeydata(&c->eyex->keys[x],frame,eyex);
setkeydata(&c->eyey->keys[x],frame,eyey);
setkeydata(&c->eyez->keys[x],frame,eyez);
setkeydata(&c->trgx->keys[x],frame,trgx);
setkeydata(&c->trgy->keys[x],frame,trgy);
setkeydata(&c->trgz->keys[x],frame,trgz);
setkeydata(&c->fovt->keys[x],frame,(float)fov);
setkeydata(&c->rollt->keys[x],frame,(float)roll);
}
c->eyex->InitVectors();
c->eyey->InitVectors();
c->eyez->InitVectors();
c->trgx->InitVectors();
c->trgy->InitVectors();
c->trgz->InitVectors();
c->fovt->InitVectors();
c->rollt->InitVectors();
}
}
//MessageBox( 0, "objload", "HelloWorld", MB_OK );
///////////////////////// OBJECT ANIM LOAD /////////////////////////////
byte animnum=readbyte(&file);
for (aa=1; aa<=animnum; aa++)
{
byte animid=readbyte(&file); //anim ID
int on;
for (on=0;on<Scene->objectnum;on++)
{
objanim *o=new objanim;
memset(o,0,sizeof(objanim));
o->next=Scene->objects[on].anims;
Scene->objects[on].anims=o;
o->number=animid;
}
for (on=0;on<Scene->objectnum;on++)
if (Scene->objects[on].data.primitive!=9 &&
Scene->objects[on].data.primitive!=11 &&
Scene->objects[on].data.primitive<100)
{
byte keyframenum=readbyte(&file);
Scene->objects[on].anims->posx=new CTrack(keyframenum);
Scene->objects[on].anims->posy=new CTrack(keyframenum);
Scene->objects[on].anims->posz=new CTrack(keyframenum);
Scene->objects[on].anims->rotx=new CTrack(keyframenum);
Scene->objects[on].anims->roty=new CTrack(keyframenum);
Scene->objects[on].anims->rotz=new CTrack(keyframenum);
Scene->objects[on].anims->rota=new CTrack(keyframenum);
Scene->objects[on].anims->strx=new CTrack(keyframenum);
Scene->objects[on].anims->stry=new CTrack(keyframenum);
Scene->objects[on].anims->strz=new CTrack(keyframenum);
Scene->objects[on].anims->colr=new CTrack(keyframenum);
Scene->objects[on].anims->colg=new CTrack(keyframenum);
Scene->objects[on].anims->colb=new CTrack(keyframenum);
Scene->objects[on].anims->cola=new CTrack(keyframenum);
if (keyframenum)
{
int frame=(unsigned short)readword(&file); //frame
float posx=readfloat(&file,floatbytes); //posx
float posy=readfloat(&file,floatbytes); //posy
float posz=readfloat(&file,floatbytes); //posz
float rotx=readfloat(&file,floatbytes); //rotx
float roty=readfloat(&file,floatbytes); //roty
float rotz=readfloat(&file,floatbytes); //rotz
int rota=readword(&file); //rota
float strx=readfloat(&file,floatbytes); //strx
float stry=readfloat(&file,floatbytes); //stry
float strz=readfloat(&file,floatbytes); //strz
float colr=(float)readbyte(&file)/255.0f; //colr
float colg=(float)readbyte(&file)/255.0f; //colg
float colb=(float)readbyte(&file)/255.0f; //colb
float cola=(float)readbyte(&file)/255.0f; //cola
setkeydata(Scene->objects[on].anims->posx->keys,frame,posx);
setkeydata(Scene->objects[on].anims->posy->keys,frame,posy);
setkeydata(Scene->objects[on].anims->posz->keys,frame,posz);
setkeydata(Scene->objects[on].anims->rotx->keys,frame,rotx);
setkeydata(Scene->objects[on].anims->roty->keys,frame,roty);
setkeydata(Scene->objects[on].anims->rotz->keys,frame,rotz);
setkeydata(Scene->objects[on].anims->rota->keys,frame,(float)rota);
setkeydata(Scene->objects[on].anims->strx->keys,frame,strx);
setkeydata(Scene->objects[on].anims->stry->keys,frame,stry);
setkeydata(Scene->objects[on].anims->strz->keys,frame,strz);
setkeydata(Scene->objects[on].anims->colr->keys,frame,colr);
setkeydata(Scene->objects[on].anims->colg->keys,frame,colg);
setkeydata(Scene->objects[on].anims->colb->keys,frame,colb);
setkeydata(Scene->objects[on].anims->cola->keys,frame,cola);
/*Scene->objects[on].anims->posx.keys[0].frame=frame;
Scene->objects[on].anims->posx.keys[0].data=posx;
Scene->objects[on].anims->posy.keys[0].frame=frame;
Scene->objects[on].anims->posy.keys[0].data=posy;
Scene->objects[on].anims->posz.keys[0].frame=frame;
Scene->objects[on].anims->posz.keys[0].data=posz;
Scene->objects[on].anims->rotx.keys[0].frame=frame;
Scene->objects[on].anims->rotx.keys[0].data=rotx;
Scene->objects[on].anims->roty.keys[0].frame=frame;
Scene->objects[on].anims->roty.keys[0].data=roty;
Scene->objects[on].anims->rotz.keys[0].frame=frame;
Scene->objects[on].anims->rotz.keys[0].data=rotz;
Scene->objects[on].anims->rota.keys[0].frame=frame;
Scene->objects[on].anims->rota.keys[0].data=(float)rota;
Scene->objects[on].anims->strx.keys[0].frame=frame;
Scene->objects[on].anims->strx.keys[0].data=strx;
Scene->objects[on].anims->stry.keys[0].frame=frame;
Scene->objects[on].anims->stry.keys[0].data=stry;
Scene->objects[on].anims->strz.keys[0].frame=frame;
Scene->objects[on].anims->strz.keys[0].data=strz;
Scene->objects[on].anims->colr.keys[0].frame=frame;
Scene->objects[on].anims->colr.keys[0].data=colr;
Scene->objects[on].anims->colg.keys[0].frame=frame;
Scene->objects[on].anims->colg.keys[0].data=colg;
Scene->objects[on].anims->colb.keys[0].frame=frame;
Scene->objects[on].anims->colb.keys[0].data=colb;
Scene->objects[on].anims->cola.keys[0].frame=frame;
Scene->objects[on].anims->cola.keys[0].data=cola;*/
for (int x=1; x<keyframenum; x++)
{
frame=readword(&file); //frame
objfield c;
memset(&c,0,sizeof(c));
memcpy(&c,file,2); //mask
file+=2;
if (c.posx) posx=readfloat(&file,floatbytes);
if (c.posy) posy=readfloat(&file,floatbytes);
if (c.posz) posz=readfloat(&file,floatbytes);
if (c.rotx) rotx=readfloat(&file,floatbytes);
if (c.roty) roty=readfloat(&file,floatbytes);
if (c.rotz) rotz=readfloat(&file,floatbytes);
if (c.rota) rota=readword(&file);
if (c.strx) strx=readfloat(&file,floatbytes);
if (c.stry) stry=readfloat(&file,floatbytes);
if (c.strz) strz=readfloat(&file,floatbytes);
if (c.colr) colr=(float)readbyte(&file)/255.f;
if (c.colg) colg=(float)readbyte(&file)/255.f;
if (c.colb) colb=(float)readbyte(&file)/255.f;
if (c.cola) cola=(float)readbyte(&file)/255.f;
/*Scene->objects[on].anims->posx.keys[x].frame=frame;
Scene->objects[on].anims->posx.keys[x].data=posx;
Scene->objects[on].anims->posy.keys[x].frame=frame;
Scene->objects[on].anims->posy.keys[x].data=posy;
Scene->objects[on].anims->posz.keys[x].frame=frame;
Scene->objects[on].anims->posz.keys[x].data=posz;
Scene->objects[on].anims->rotx.keys[x].frame=frame;
Scene->objects[on].anims->rotx.keys[x].data=rotx;
Scene->objects[on].anims->roty.keys[x].frame=frame;
Scene->objects[on].anims->roty.keys[x].data=roty;
Scene->objects[on].anims->rotz.keys[x].frame=frame;
Scene->objects[on].anims->rotz.keys[x].data=rotz;
Scene->objects[on].anims->rota.keys[x].frame=frame;
Scene->objects[on].anims->rota.keys[x].data=(float)rota;
Scene->objects[on].anims->strx.keys[x].frame=frame;
Scene->objects[on].anims->strx.keys[x].data=strx;
Scene->objects[on].anims->stry.keys[x].frame=frame;
Scene->objects[on].anims->stry.keys[x].data=stry;
Scene->objects[on].anims->strz.keys[x].frame=frame;
Scene->objects[on].anims->strz.keys[x].data=strz;
Scene->objects[on].anims->colr.keys[x].frame=frame;
Scene->objects[on].anims->colr.keys[x].data=colr;
Scene->objects[on].anims->colg.keys[x].frame=frame;
Scene->objects[on].anims->colg.keys[x].data=colg;
Scene->objects[on].anims->colb.keys[x].frame=frame;
Scene->objects[on].anims->colb.keys[x].data=colb;
Scene->objects[on].anims->cola.keys[x].frame=frame;
Scene->objects[on].anims->cola.keys[x].data=cola;*/
setkeydata(&Scene->objects[on].anims->posx->keys[x],frame,posx);
setkeydata(&Scene->objects[on].anims->posy->keys[x],frame,posy);
setkeydata(&Scene->objects[on].anims->posz->keys[x],frame,posz);
setkeydata(&Scene->objects[on].anims->rotx->keys[x],frame,rotx);
setkeydata(&Scene->objects[on].anims->roty->keys[x],frame,roty);
setkeydata(&Scene->objects[on].anims->rotz->keys[x],frame,rotz);
setkeydata(&Scene->objects[on].anims->rota->keys[x],frame,(float)rota);
setkeydata(&Scene->objects[on].anims->strx->keys[x],frame,strx);
setkeydata(&Scene->objects[on].anims->stry->keys[x],frame,stry);
setkeydata(&Scene->objects[on].anims->strz->keys[x],frame,strz);
setkeydata(&Scene->objects[on].anims->colr->keys[x],frame,colr);
setkeydata(&Scene->objects[on].anims->colg->keys[x],frame,colg);
setkeydata(&Scene->objects[on].anims->colb->keys[x],frame,colb);
setkeydata(&Scene->objects[on].anims->cola->keys[x],frame,cola);
}
Scene->objects[on].anims->posx->InitVectors();
Scene->objects[on].anims->posy->InitVectors();
Scene->objects[on].anims->posz->InitVectors();
Scene->objects[on].anims->rotx->InitVectors();
Scene->objects[on].anims->roty->InitVectors();
Scene->objects[on].anims->rotz->InitVectors();
Scene->objects[on].anims->rota->InitVectors();
Scene->objects[on].anims->strx->InitVectors();
Scene->objects[on].anims->stry->InitVectors();
Scene->objects[on].anims->strz->InitVectors();
Scene->objects[on].anims->colr->InitVectors();
Scene->objects[on].anims->colg->InitVectors();
Scene->objects[on].anims->colb->InitVectors();
Scene->objects[on].anims->cola->InitVectors();
}
}
}
Scene->next=scenelist;
scenelist=Scene;
}
////////////////////////// EVENT LOAD ///////////////////////////////
int eventnum=readword(&file);
for (aa=1; aa<=eventnum; aa++)
{
event *e=new event;
memset(e,0,sizeof(event));
if (eventlist==NULL)
{
eventlist=e;
lastevent=e;
}
else
{
lastevent->next=e;
lastevent=e;
}
e->eventtype=readbyte(&file);
e->startframe=(unsigned short)readword(&file)*10; //startframe
e->endframe=(unsigned short)readword(&file)*10+9; //endframe
e->pass=readbyte(&file); //pass
if (e->eventtype==layer2d || e->eventtype==layer3d || e->eventtype==rendertotext || e->eventtype==feedback || e->eventtype==grideffect)
{
e->startrectx1=readword(&file);
e->startrecty1=readword(&file);
e->startrectx2=readword(&file);
e->startrecty2=readword(&file);
e->endrectx1=readword(&file);
e->endrecty1=readword(&file);
e->endrectx2=readword(&file);
e->endrecty2=readword(&file);
}
if (e->eventtype==layer2d || e->eventtype==feedback || e->eventtype==grideffect)
{
e->startcol[0]=(float)readbyte(&file)/255.0f;
e->startcol[1]=(float)readbyte(&file)/255.0f;
e->startcol[2]=(float)readbyte(&file)/255.0f;
e->startcol[3]=(float)readbyte(&file)/255.0f;
e->endcol[0]=(float)readbyte(&file)/255.0f;
e->endcol[1]=(float)readbyte(&file)/255.0f;
e->endcol[2]=(float)readbyte(&file)/255.0f;
e->endcol[3]=(float)readbyte(&file)/255.0f;
switch (readbyte(&file))
{
case 0:e->blendfunc1=GL_ZERO; break;
case 1:e->blendfunc1=GL_ONE; break;
case 2:e->blendfunc1=GL_SRC_COLOR; break;
case 3:e->blendfunc1=GL_ONE_MINUS_SRC_COLOR; break;
case 4:e->blendfunc1=GL_SRC_ALPHA; break;
case 5:e->blendfunc1=GL_ONE_MINUS_SRC_ALPHA; break;
case 6:e->blendfunc1=GL_DST_ALPHA; break;
case 7:e->blendfunc1=GL_ONE_MINUS_DST_ALPHA; break;
case 8:e->blendfunc1=GL_DST_COLOR; break;
case 9:e->blendfunc1=GL_ONE_MINUS_DST_COLOR; break;
case 10:e->blendfunc1=GL_SRC_ALPHA_SATURATE; break;
}
switch (readbyte(&file))
{
case 0:e->blendfunc2=GL_ZERO; break;
case 1:e->blendfunc2=GL_ONE; break;
case 2:e->blendfunc2=GL_SRC_COLOR; break;
case 3:e->blendfunc2=GL_ONE_MINUS_SRC_COLOR; break;
case 4:e->blendfunc2=GL_SRC_ALPHA; break;
case 5:e->blendfunc2=GL_ONE_MINUS_SRC_ALPHA; break;
case 6:e->blendfunc2=GL_DST_ALPHA; break;
case 7:e->blendfunc2=GL_ONE_MINUS_DST_ALPHA; break;
case 8:e->blendfunc2=GL_DST_COLOR; break;
case 9:e->blendfunc2=GL_ONE_MINUS_DST_COLOR; break;
case 10:e->blendfunc2=GL_SRC_ALPHA_SATURATE; break;
}
}
switch (e->eventtype)
{
case layer2d:
{
e->textured=readbyte(&file);
e->texture=readbyte(&file);
e->mattexture=findmaterial(e->texture)->handle;
break;
}
case layer3d:
{
e->sceneid=readbyte(&file);
e->camid=readbyte(&file);
e->animid=readbyte(&file);
e->camstart=readword(&file);
e->camend=readword(&file);
e->animstart=readword(&file);
e->animend=readword(&file);
e->iscene=findscene(e->sceneid);
e->icam=findcam(e->iscene,e->camid);
e->ianim=e->animid;
break;
}
case cleargl:
{
e->clearscreen=readbyte(&file);
e->clearzbuffer=readbyte(&file);
break;
}
case rendertotext:
{
e->texture=readbyte(&file);
break;
}
case feedback:
{
e->texture=readbyte(&file);
e->param1=readbyte(&file);
e->param4=readfloat(&file,floatbytes);
break;
}
case grideffect:
{
e->texture=readbyte(&file);
e->effect=readbyte(&file);
e->gridstart=readfloat(&file,floatbytes);
e->gridend=readfloat(&file,floatbytes);
break;
}
}
}
}
int main(int argc, char** argv)
{
int d;
double **matr1, **matr2;
int n1, n2;
int m1, m2;
FILE *fin1; // первый исходный файл
FILE *fin2; // второй исходный файл
FILE *fout1; // файл для печати cуммы
FILE *fout2; // файл для печати произведения
FILE *fout3; // файл для печати матрицы, обратной к первой
setlocale(0, "russian");
if (argc < 6)
{
printf("Нет достаточного числа аргументов!");
return BADARG;
}
fin1 = fopen(argv[1], "r");
if (fin1 == NULL)
{
printf("Невозможно открыть первый исходный файл!");
return BADINFILE1;
}
fin2 = fopen(argv[2], "r");
if (fin2 == NULL)
{
fclose(fin1);
printf("Невозможно открыть второй исходный файл!");
return BADINFILE2;
}
fout1 = fopen(argv[3], "w");
if (fout1 == NULL)
{
printf("Невозможно открыть файл результата #1!");
fclose(fin1);
fclose(fin2);
return BADOUTFILE1;
}
fout2 = fopen(argv[4], "w");
if (fout1 == NULL)
{
printf("Невозможно открыть файл результата #2!");
fclose(fin1);
fclose(fin2);
return BADOUTFILE2;
}
fout3 = fopen(argv[5], "w");
if (fout1 == NULL)
{
printf("Невозможно открыть файл результата #3!");
fclose(fin1);
fclose(fin2);
return BADOUTFILE3;
}
if ((d = readmatrix(fin1, &matr1, &n1, &m1))!=0)
{
printf("Невозможно считать первую исходную матрицу!");
fclose(fin1);
fclose(fin2);
fclose(fout1);
fclose(fout2);
fclose(fout3);
switch (d)
{
case 1:
printf("\nНеверная размерность!");
return FAILEDDIM1;
case 2:
printf("\nНеверные тип и количество данных!");
return FAILEDDATE1;
case 3:
printf("\nНевозможно выделить память под матрицу!");
return FAILEDMEM1;
}
}
if ((d = readmatrix(fin2, &matr2, &n2, &m2))!=0)
{
printf("Невозможно считать вторую исходную матрицу!");
fclose(fin1);
fclose(fin2);
fclose(fout1);
fclose(fout2);
fclose(fout3);
free_matrix(matr1, n1);
switch (d)
{
case 1:
printf("\nНеверная размерность!");
return FAILEDDIM2;
case 2:
printf("\nНеверные тип и количество данных!");
return FAILEDDATE2;
case 3:
printf("\nНевозможно выделить память под матрицу!");
return FAILEDMEM2;
}
}
double** sumst = summstr(matr1, n1, m1, matr2, n2, m2);
if (sumst != NULL)
{
printmatrix(fout1, sumst, n1, m1);
printf("\nCложение успешно!\n");
free_matrix(sumst, n1);
}
else
printf("\nНевозможно выполнить сложение!\n");
double** mulst = multstr(matr1, n1, m1, matr2, n2, m2);
if (mulst != NULL)
{
printmatrix(fout2, mulst, n1, m2);
printf("\nУмножение успешно!\n");
free_matrix(mulst, n1);
}
else
printf("\nНевозможно выполнить умножение!\n");
double** obrst = gaussobr(matr1, n1, m1);;
if (obrst != NULL)
{
printmatrix(fout3, obrst, n1, m1);
printf("\nОбратная матрица найдена успешно успешно!\n");
free_matrix(obrst, n1);
}
else
printf("\nНевозможно выполнить сложение!\n");
fclose(fin1);
fclose(fin2);
fclose(fout1);
fclose(fout2);
free_matrix(matr1, n1);
free_matrix(matr2, n2);
return 0;
}
int main(int argc, char **argv)
{
FILE *ofd,*ifd;
ALN mult_aln;
OPT opt;
char infile[FILENAMELEN+1];
char outfile[FILENAMELEN+1];
int nseqs;
int i,j,l,n,ires;
int err,ix,ntot;
float min_nn,nn;
float tmp;
Boolean eof,found;
if(argc!=3 && argc!=7 && argc!=8) {
usage(argv[0]);
return 0;
}
strcpy(infile,argv[1]);
strcpy(outfile,argv[2]);
/* open the matrix file */
verbose=FALSE;
if(argc==3) {
get_default_matrix();
go=0.0;
ge=0.1;
egap=0.0;
}
else {
if(argc==8) verbose=TRUE;
if((ifd=fopen(argv[3],"r"))==NULL) {
fprintf(stderr,"Cannot open matrix file [%s]",argv[3]);
return 0;
}
err=readmatrix(ifd);
if(err<=0) {
fprintf(stderr,"Error: bad matrix in %s\n",argv[3]);
return 0;
}
go=atof(argv[4]);
ge=atof(argv[5]);
egap=atof(argv[6]);
}
init_options(&opt);
(*opt.alnout_opt).output_clustal=FALSE;
(*opt.alnout_opt).output_relacs=TRUE;
/* read in the sequences */
seq_input(infile,opt.explicit_type,FALSE,&mult_aln);
if(mult_aln.nseqs<=0) {
error("No sequences in %s\n",infile);
exit(1);
}
nseqs=mult_aln.nseqs;
/* remove the gaps */
seqlength=0;
useqlen_array=(int *)ckalloc((nseqs+1)*sizeof(int));
for(i=0;i<nseqs;i++) {
if(mult_aln.seqs[i].len>seqlength) seqlength=mult_aln.seqs[i].len;
l=0;
for(j=0;j<mult_aln.seqs[i].len;j++)
if(isalpha(mult_aln.seqs[i].data[j])) {
l++;
}
useqlen_array[i]=l;
}
maxlen=0;
for(i=0;i<nseqs;i++)
if(useqlen_array[i]>maxlen) maxlen=useqlen_array[i];
minlen=10000;
for(i=0;i<nseqs;i++)
if(useqlen_array[i]<minlen) minlen=useqlen_array[i];
/* remove any column score data that already exists in the input file */
/*if (mult_aln.ncol_scores==1)
ckfree(mult_aln.col_score[0].data);*/
ix=mult_aln.ncol_scores;
mult_aln.col_score[ix].data=(sint *)ckalloc((seqlength+1)*sizeof(sint));
mult_aln.ncol_scores=ix+1;
/* calculate some simple statistics */
pcid=(float **)ckalloc((nseqs+1)*sizeof(float *));
for(i=0;i<nseqs;i++)
pcid[i]=(float *)ckalloc((nseqs+1)*sizeof(float));
for(i=0;i<nseqs;i++) {
for(j=i+1;j<nseqs;j++) {
pcid[j][i]=pcid[i][j]=pcidentity(mult_aln,i,j);
}
}
/* find the nearest neighbor for each sequence */
min_nn=1.0;
for(i=0;i<nseqs;i++) {
nn=0.0;
for(j=0;j<nseqs;j++) {
if(i!=j && pcid[i][j]>nn) nn=pcid[i][j];
}
if(nn<min_nn) min_nn=nn;
}
seqweight=(float **)ckalloc((nseqs+1)*sizeof(float *));
for(i=0;i<nseqs;i++)
seqweight[i]=(float *)ckalloc((nseqs+1)*sizeof(float));
for(i=0;i<nseqs;i++)
for(j=i;j<nseqs;j++) {
seqweight[j][i]=seqweight[i][j]=1.0-pcid[i][j];
}
fragment=(Boolean *)ckalloc((nseqs+1)*sizeof(Boolean));
/* calculate pairwise alignment scores using k-tuple scores */
qpw_id=(float **)ckalloc((nseqs+1)*sizeof(float *));
for(i=0;i<nseqs;i++)
qpw_id[i]=(float *)ckalloc((nseqs+1)*sizeof(float));
for(i=0,n=0;i<nseqs;i++)
for(j=i+1;j<nseqs;j++) {
qpw_id[i][j]=100.0*pcid[i][j];
if(qpw_id[i][j]<60) {
qpw_id[i][j]=show_pair(mult_aln,i,j);
}
if(qpw_id[i][j]>40) {
tmp=(float)useqlen_array[i]/(float)useqlen_array[j];
if(tmp<0.8) fragment[i]=TRUE;
else if(tmp>1.25) fragment[j]=TRUE;
}
n++;
}
/*if(verbose)
for(i=0;i<nseqs;i++)
if(fragment[i]) fprintf(stdout,"%s fragment %s\n",argv[1],names[i]);*/
/* calculate sequence groups and keep first sequence in each group for processing */
use_seq=(int *)ckalloc((nseqs+1)*sizeof(int));
for(i=0;i<nseqs;i++)
use_seq[i]=2;
query=0;
seqgroup=(int *)ckalloc((nseqs+1)*sizeof(int));
groupseed=(int *)ckalloc((nseqs+1)*sizeof(int));
calc_groups(query,0.7,nseqs,pcid,seqgroup,groupseed);
if(ngroups<=0) {
fprintf(stderr,"Error: problem with sequence grouping\n");
exit(1);
}
for(j=0;j<nseqs;j++) use_seq[j]=(-1);
for(i=0;i<ngroups;i++) {
j=groupseed[i];
use_seq[j]=2;
}
for(i=0;i<nseqs;i++)
ckfree(pcid[i]);
ckfree(pcid);
ckfree(groupseed);
ckfree(seqgroup);
qpw=(float *)ckalloc((ngroups*ngroups+1)*sizeof(float));
for(i=0,n=0;i<nseqs;i++)
if(use_seq[i]>1)
for(j=i+1;j<nseqs;j++)
if(use_seq[j]>1)
qpw[n++]=qpw_id[i][j];
for(i=0;i<nseqs;i++)
ckfree(qpw_id[i]);
ckfree(qpw_id);
/* sort the pairwise k-tuple scores into ascending order */
sort_scores(qpw,0,n-1);
/* calculate the scores for the gaps */
gop=(float **)ckalloc((nseqs+1)*sizeof(float *));
for(i=0;i<nseqs;i++)
gop[i]=(float *)ckalloc((nseqs+1)*sizeof(float));
gep=(float **)ckalloc((nseqs+1)*sizeof(float *));
for(i=0;i<nseqs;i++)
gep[i]=(float *)ckalloc((nseqs+1)*sizeof(float));
egp=(float **)ckalloc((nseqs+1)*sizeof(float *));
for(i=0;i<nseqs;i++)
egp[i]=(float *)ckalloc((nseqs+1)*sizeof(float));
for(i=0;i<nseqs;i++)
if(use_seq[i]>1)
for(j=i+1;j<nseqs;j++)
if(use_seq[j]>1)
score_gaps(mult_aln,i,j);
calc_md(&mult_aln,ix);
for(i=0,ntot=0;i<nseqs;i++)
if(use_seq[i]>1) {
ntot++;
}
tmp=set_mdcutoff(ntot,q1);
normd_rs/=tmp;
tmp=1.0;
norm_md/=tmp;
mult_aln.alnscore=norm_md;
mult_aln.validalnscore=TRUE;
if(!verbose) {
fprintf(stdout,"%s\t%.3f\n",argv[1],norm_md);
/*fprintf(stdout,"%.3f\n",norm_md);*/
} else {
/*fprintf(stdout,"%s %.3f %.3f %.3f %.3f %.3f %.3f %d %d %d\n",
argv[1],norm_md,normd_rs,col,max_colscore,gap_extscore*0.1,q1,nseqs,minlen,maxlen);*/
fprintf(stdout,"FILE %s\n",argv[1]);
fprintf(stdout,"norMD %.3f\n",norm_md);
/*fprintf(stdout,"norMD_of %.3f\n",norm_md);
fprintf(stdout,"norMD_rs %.3f\n",normd_rs);*/
fprintf(stdout,"NSEQS %d\n",nseqs);
fprintf(stdout,"MD %.3f\n",col);
fprintf(stdout,"maxMD %.3f\n",max_colscore);
fprintf(stdout,"GOP %.3f\n",gap_openscore);
fprintf(stdout,"GEP %.3f\n",gap_extscore);
fprintf(stdout,"LQR %.3f\n",q1);
}
for(i=0;i<nseqs;i++)
ckfree(gop[i]);
ckfree(gop);
for(i=0;i<nseqs;i++)
ckfree(gep[i]);
ckfree(gep);
for(i=0;i<nseqs;i++)
ckfree(egp[i]);
ckfree(egp);
for(i=0;i<nseqs;i++)
ckfree(seqweight[i]);
ckfree(seqweight);
ckfree(qpw);
ckfree(use_seq);
ckfree(fragment);
ckfree(useqlen_array);
/* write out the sequences */
strcpy(opt.alnout_opt->relacs_outname,outfile);
if(!open_alignment_output(outfile,opt.alnout_opt)) exit(1);
create_alignment_output(mult_aln,*opt.alnout_opt);
return 0;
}
iMatrix *getData(const char * pName){
return readmatrix(std::string(pName),"\t ;,:");
}
