void Monitord() { time_t tm; struct tm *p; int today = 0; int thismonth = 0; int thisyear = 0; char str[OS_SIZE_1024 + 1]; /* Wait a few seconds to settle */ sleep(10); memset(str, '\0', OS_SIZE_1024 + 1); /* Get current time before starting */ tm = time(NULL); p = localtime(&tm); today = p->tm_mday; thismonth = p->tm_mon; thisyear = p->tm_year + 1900; /* Connect to the message queue or exit */ if ((mond.a_queue = StartMQ(DEFAULTQUEUE, WRITE)) < 0) { ErrorExit(QUEUE_FATAL, ARGV0, DEFAULTQUEUE); } /* Send startup message */ snprintf(str, OS_SIZE_1024 - 1, OS_AD_STARTED); if (SendMSG(mond.a_queue, str, ARGV0, LOCALFILE_MQ) < 0) { merror(QUEUE_SEND, ARGV0); } /* Main monitor loop */ while (1) { tm = time(NULL); p = localtime(&tm); /* Check for unavailable agents */ if (mond.monitor_agents) { monitor_agents(); } /* Day changed, deal with log files */ if (today != p->tm_mday) { /* Generate reports */ generate_reports(today, thismonth, thisyear, p); manage_files(today, thismonth, thisyear); today = p->tm_mday; thismonth = p->tm_mon; thisyear = p->tm_year + 1900; } /* We only check every two minutes */ sleep(120); } }
int main(int argc, char *argv[]) { char **av; MRI *mri_src, *mri_mask, *mri_dst ; int nargs, ac, nmask; int x, y, z; float value; MRI_REGION *region; LTA *lta = 0; int transform_type; MRI *mri_tmp; nargs = handle_version_option ( argc, argv, "$Id: mri_mask.c,v 1.18 2012/12/07 22:45:50 greve Exp $", "$Name: $" ); if (nargs && argc - nargs == 1) { exit (0); } argc -= nargs ; Progname = argv[0]; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc != 4) { printf("Incorrect number of arguments, argc = %d\n", argc); usage(1); } mri_src = MRIread(argv[1]) ; if (!mri_src) ErrorExit(ERROR_BADPARM, "%s: could not read source volume %s", Progname, argv[1]) ; mri_mask = MRIread(argv[2]) ; if (!mri_mask) ErrorExit(ERROR_BADPARM, "%s: could not read mask volume %s", Progname, argv[2]) ; if(mri_src->width != mri_mask->width) { printf("ERROR: dimension mismatch between source and mask\n"); exit(1); } printf("DoAbs = %d\n",DoAbs); /* Read LTA transform and apply it to mri_mask */ if (xform_fname != NULL) { printf("Apply the given LTA xfrom to the mask volume\n"); // read transform transform_type = TransformFileNameType(xform_fname); if (transform_type == MNI_TRANSFORM_TYPE || transform_type == TRANSFORM_ARRAY_TYPE || transform_type == REGISTER_DAT || transform_type == FSLREG_TYPE ) { printf("Reading transform ...\n"); lta = LTAreadEx(xform_fname) ; if (!lta) ErrorExit(ERROR_NOFILE, "%s: could not read transform file %s", Progname, xform_fname) ; if (transform_type == FSLREG_TYPE) { if (lta_src == 0 || lta_dst == 0) { fprintf(stderr, "ERROR: fslmat does not have information on " "the src and dst volumes\n"); fprintf(stderr, "ERROR: you must give options '-lta_src' " "and '-lta_dst' to specify the src and dst volume infos\n"); } LTAmodifySrcDstGeom(lta, lta_src, lta_dst); // add src and dst information LTAchangeType(lta, LINEAR_VOX_TO_VOX); } if (lta->xforms[0].src.valid == 0) { if (lta_src == 0) { fprintf(stderr, "The transform does not have the valid src volume info.\n"); fprintf(stderr, "Either you give src volume info by option -lta_src or\n"); fprintf(stderr, "make the transform to have the valid src info.\n"); ErrorExit(ERROR_BAD_PARM, "Bailing out...\n"); } else { LTAmodifySrcDstGeom(lta, lta_src, NULL); // add src information // getVolGeom(lta_src, <->src); } } if (lta->xforms[0].dst.valid == 0) { if (lta_dst == 0) { fprintf(stderr, "The transform does not have the valid dst volume info.\n"); fprintf(stderr, "Either you give src volume info by option -lta_dst or\n"); fprintf(stderr, "make the transform to have the valid dst info.\n"); fprintf(stderr, "If the dst was average_305, then you can set\n"); fprintf(stderr, "environmental variable USE_AVERAGE305 true\n"); fprintf(stderr, "without giving the dst volume for RAS-to-RAS transform.\n"); ErrorExit(ERROR_BAD_PARM, "Bailing out...\n"); } else { LTAmodifySrcDstGeom(lta, NULL, lta_dst); // add dst information } } } else { ErrorExit(ERROR_BADPARM, "transform is not of MNI, nor Register.dat, nor FSLMAT type"); } if (invert) { VOL_GEOM vgtmp; LT *lt; MATRIX *m_tmp = lta->xforms[0].m_L ; lta->xforms[0].m_L = MatrixInverse(lta->xforms[0].m_L, NULL) ; MatrixFree(&m_tmp) ; lt = <a->xforms[0]; if (lt->dst.valid == 0 || lt->src.valid == 0) { fprintf(stderr, "WARNING:**************************************" "*************************\n"); fprintf(stderr, "WARNING:dst volume information is invalid. " "Most likely produced wrong inverse.\n"); fprintf(stderr, "WARNING:**************************************" "*************************\n"); } copyVolGeom(<->dst, &vgtmp); copyVolGeom(<->src, <->dst); copyVolGeom(&vgtmp, <->src); } // LTAchangeType(lta, LINEAR_VOX_TO_VOX); mri_tmp = MRIalloc(mri_src->width, mri_src->height, mri_src->depth, mri_mask->type) ; MRIcopyHeader(mri_src, mri_tmp) ; mri_tmp = LTAtransformInterp(mri_mask, mri_tmp, lta, InterpMethod); // mri_tmp = //MRIlinearTransformInterp // ( // mri_mask, mri_tmp, lta->xforms[0].m_L, InterpMethod // ); MRIfree(&mri_mask); mri_mask = mri_tmp; if (lta_src) { MRIfree(<a_src); } if (lta_dst) { MRIfree(<a_dst); } if (lta) { LTAfree(<a); } } /* if (xform_fname != NULL) */ // Threshold mask nmask = 0; for (z = 0 ; z <mri_mask->depth ; z++) { for (y = 0 ; y < mri_mask->height ; y++) { for (x = 0 ; x < mri_mask->width ; x++) { value = MRIgetVoxVal(mri_mask, x, y, z, 0); if(DoAbs) { value = fabs(value); } if(value <= threshold) { MRIsetVoxVal(mri_mask,x,y,z,0,0); } else { nmask ++; } } } } printf("Found %d voxels in mask (pct=%6.2f)\n",nmask, 100.0*nmask/(mri_mask->width*mri_mask->height*mri_mask->depth)); if(DoBB){ printf("Computing bounding box, npad = %d\n",nPadBB); region = REGIONgetBoundingBox(mri_mask,nPadBB); REGIONprint(stdout, region); mri_tmp = MRIextractRegion(mri_mask, NULL, region); if(mri_tmp == NULL) exit(1); MRIfree(&mri_mask); mri_mask = mri_tmp; mri_tmp = MRIextractRegion(mri_src, NULL, region); if(mri_tmp == NULL) exit(1); MRIfree(&mri_src); mri_src = mri_tmp; } int mask=0; float out_val=0; if (do_transfer) { mask = (int)transfer_val; out_val = transfer_val; } mri_dst = MRImask(mri_src, mri_mask, NULL, mask, out_val) ; if (!mri_dst) { ErrorExit(Gerror, "%s: stripping failed", Progname) ; } if (keep_mask_deletion_edits) { mri_dst = MRImask(mri_dst, mri_mask, NULL, 1, 1) ; // keep voxels = 1 if (!mri_dst) ErrorExit(Gerror, "%s: stripping failed on keep_mask_deletion_edits", Progname) ; } printf("Writing masked volume to %s...", argv[3]) ; MRIwrite(mri_dst, argv[3]); printf("done.\n") ; MRIfree(&mri_src); MRIfree(&mri_mask); MRIfree(&mri_dst); exit(0); } /* end main() */
void Process::run() { SECURITY_ATTRIBUTES saAttr; // Set the bInheritHandle flag so pipe handles are inherited. saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); saAttr.bInheritHandle = TRUE; saAttr.lpSecurityDescriptor = NULL; // Create a pipe for the child process's STDOUT. if ( ! CreatePipe(&g_hChildStd_OUT_Rd, &g_hChildStd_OUT_Wr, &saAttr, 0) ) ErrorExit(TEXT("StdoutRd CreatePipe")); // Ensure the read handle to the pipe for STDOUT is not inherited. if ( ! SetHandleInformation(g_hChildStd_OUT_Rd, HANDLE_FLAG_INHERIT, 0) ) ErrorExit(TEXT("Stdout SetHandleInformation")); // Create a pipe for the child process's STDIN. if (! CreatePipe(&g_hChildStd_IN_Rd, &g_hChildStd_IN_Wr, &saAttr, 0)) ErrorExit(TEXT("Stdin CreatePipe")); // Ensure the write handle to the pipe for STDIN is not inherited. if ( ! SetHandleInformation(g_hChildStd_IN_Wr, HANDLE_FLAG_INHERIT, 0) ) ErrorExit(TEXT("Stdin SetHandleInformation")); std::string mycmd = "cmd.exe /D /c " + cmd; //Create child process PROCESS_INFORMATION piProcInfo; STARTUPINFO siStartInfo; BOOL bSuccess = FALSE; // Set up members of the PROCESS_INFORMATION structure. ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) ); // Set up members of the STARTUPINFO structure. // This structure specifies the STDIN and STDOUT handles for redirection. ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) ); siStartInfo.cb = sizeof(STARTUPINFO); siStartInfo.hStdError = g_hChildStd_OUT_Wr; siStartInfo.hStdOutput = g_hChildStd_OUT_Wr; siStartInfo.hStdInput = g_hChildStd_IN_Rd; siStartInfo.dwFlags |= STARTF_USESTDHANDLES; // Create the child process. bSuccess = CreateProcess( NULL, (LPSTR)cmd.c_str(), // command line NULL, // process security attributes NULL, // primary thread security attributes TRUE, // handles are inherited 0, // creation flags NULL, // use parent's environment NULL, // use parent's current directory &siStartInfo, // STARTUPINFO pointer &piProcInfo); // receives PROCESS_INFORMATION // If an error occurs, exit the application. if ( ! bSuccess ) ErrorExit(TEXT("CreateProcess")); else { running = true; /******************************************************************************** * IF YOU PLAN TO ATTACH TO YOUR'S BOTS PROCESS, UNCOMMENT OUT THIS CODE TO HELP. * IT WILL PAUSE UNTIL YOU TYPE A KEY AND HIT ENTER * ********************************************************************************/ //if( cmd == "C:\\planetwars\\cpp_framework\\albertz-planet_wars-cpp-2fc1dda\\VC\\Debug\\alcsbot.exe" ) //{ // std::cout << "Attach to mybot.exe process, type some char and hit enter when ready"; // char n; // std::cin >> n; //} //CloseHandle(piProcInfo.hProcess); hProcess = piProcInfo.hProcess; CloseHandle(piProcInfo.hThread); } }
float Falign_localhom( char **seq1, char **seq2, double *eff1, double *eff2, int clus1, int clus2, int alloclen, LocalHom ***localhom, float *totalimpmatch, int *gapmap1, int *gapmap2, int *chudanpt, int chudanref, int *chudanres ) { // tditeration.c deha alloclen ha huhen nanode // prevalloclen ha iranai. int i, j, k, l, m, maxk; int nlen, nlen2, nlen4; static TLS int crossscoresize = 0; static TLS char **tmpseq1 = NULL; static TLS char **tmpseq2 = NULL; static TLS char **tmpptr1 = NULL; static TLS char **tmpptr2 = NULL; static TLS char **tmpres1 = NULL; static TLS char **tmpres2 = NULL; static TLS char **result1 = NULL; static TLS char **result2 = NULL; #if RND static TLS char **rndseq1 = NULL; static TLS char **rndseq2 = NULL; #endif static TLS Fukusosuu **seqVector1 = NULL; static TLS Fukusosuu **seqVector2 = NULL; static TLS Fukusosuu **naiseki = NULL; static TLS Fukusosuu *naisekiNoWa = NULL; static TLS double *soukan = NULL; static TLS double **crossscore = NULL; int nlentmp; static TLS int *kouho = NULL; static TLS Segment *segment = NULL; static TLS Segment *segment1 = NULL; static TLS Segment *segment2 = NULL; static TLS Segment **sortedseg1 = NULL; static TLS Segment **sortedseg2 = NULL; static TLS int *cut1 = NULL; static TLS int *cut2 = NULL; static TLS char *sgap1, *egap1, *sgap2, *egap2; static TLS int localalloclen = 0; int lag; int tmpint; int count, count0; int len1, len2; int totallen; float totalscore; float impmatch; extern Fukusosuu *AllocateFukusosuuVec(); extern Fukusosuu **AllocateFukusosuuMtx(); if( seq1 == NULL ) { if( result1 ) { // fprintf( stderr, "Freeing localarrays in Falign\n" ); localalloclen = 0; mymergesort( 0, 0, NULL ); alignableReagion( 0, 0, NULL, NULL, NULL, NULL, NULL ); fft( 0, NULL, 1 ); A__align( NULL, NULL, NULL, NULL, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL, 0, 0 ); G__align11( NULL, NULL, 0, 0, 0 ); partA__align( NULL, NULL, NULL, NULL, 0, 0, 0, NULL, NULL, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, NULL ); blockAlign2( NULL, NULL, NULL, NULL, NULL, NULL ); if( crossscore ) FreeDoubleMtx( crossscore ); FreeCharMtx( result1 ); FreeCharMtx( result2 ); FreeCharMtx( tmpres1 ); FreeCharMtx( tmpres2 ); FreeCharMtx( tmpseq1 ); FreeCharMtx( tmpseq2 ); free( sgap1 ); free( egap1 ); free( sgap2 ); free( egap2 ); free( kouho ); free( cut1 ); free( cut2 ); free( tmpptr1 ); free( tmpptr2 ); free( segment ); free( segment1 ); free( segment2 ); free( sortedseg1 ); free( sortedseg2 ); if( !kobetsubunkatsu ) { FreeFukusosuuMtx ( seqVector1 ); FreeFukusosuuMtx ( seqVector2 ); FreeFukusosuuVec( naisekiNoWa ); FreeFukusosuuMtx( naiseki ); FreeDoubleVec( soukan ); } } else { // fprintf( stderr, "Did not allocate localarrays in Falign\n" ); } return( 0.0 ); } len1 = strlen( seq1[0] ); len2 = strlen( seq2[0] ); nlentmp = MAX( len1, len2 ); nlen = 1; while( nlentmp >= nlen ) nlen <<= 1; #if 0 fprintf( stderr, "### nlen = %d\n", nlen ); #endif nlen2 = nlen/2; nlen4 = nlen2 / 2; #if DEBUG fprintf( stderr, "len1 = %d, len2 = %d\n", len1, len2 ); fprintf( stderr, "nlentmp = %d, nlen = %d\n", nlentmp, nlen ); #endif if( !localalloclen ) { sgap1 = AllocateCharVec( njob ); egap1 = AllocateCharVec( njob ); sgap2 = AllocateCharVec( njob ); egap2 = AllocateCharVec( njob ); kouho = AllocateIntVec( NKOUHO ); cut1 = AllocateIntVec( MAXSEG ); cut2 = AllocateIntVec( MAXSEG ); tmpptr1 = AllocateCharMtx( njob, 0 ); tmpptr2 = AllocateCharMtx( njob, 0 ); result1 = AllocateCharMtx( njob, alloclen ); result2 = AllocateCharMtx( njob, alloclen ); tmpres1 = AllocateCharMtx( njob, alloclen ); tmpres2 = AllocateCharMtx( njob, alloclen ); // crossscore = AllocateDoubleMtx( MAXSEG, MAXSEG ); segment = (Segment *)calloc( MAXSEG, sizeof( Segment ) ); segment1 = (Segment *)calloc( MAXSEG, sizeof( Segment ) ); segment2 = (Segment *)calloc( MAXSEG, sizeof( Segment ) ); sortedseg1 = (Segment **)calloc( MAXSEG, sizeof( Segment * ) ); sortedseg2 = (Segment **)calloc( MAXSEG, sizeof( Segment * ) ); if( !( segment && segment1 && segment2 && sortedseg1 && sortedseg2 ) ) ErrorExit( "Allocation error\n" ); if ( scoremtx == -1 ) n20or4or2 = 4; else if( fftscore == 1 ) n20or4or2 = 2; else n20or4or2 = 20; } if( localalloclen < nlen ) { if( localalloclen ) { #if 1 if( !kobetsubunkatsu ) { FreeFukusosuuMtx ( seqVector1 ); FreeFukusosuuMtx ( seqVector2 ); FreeFukusosuuVec( naisekiNoWa ); FreeFukusosuuMtx( naiseki ); FreeDoubleVec( soukan ); } FreeCharMtx( tmpseq1 ); FreeCharMtx( tmpseq2 ); #endif #if RND FreeCharMtx( rndseq1 ); FreeCharMtx( rndseq2 ); #endif } tmpseq1 = AllocateCharMtx( njob, nlen ); tmpseq2 = AllocateCharMtx( njob, nlen ); if( !kobetsubunkatsu ) { naisekiNoWa = AllocateFukusosuuVec( nlen ); naiseki = AllocateFukusosuuMtx( n20or4or2, nlen ); seqVector1 = AllocateFukusosuuMtx( n20or4or2+1, nlen+1 ); seqVector2 = AllocateFukusosuuMtx( n20or4or2+1, nlen+1 ); soukan = AllocateDoubleVec( nlen+1 ); } #if RND rndseq1 = AllocateCharMtx( njob, nlen ); rndseq2 = AllocateCharMtx( njob, nlen ); for( i=0; i<njob; i++ ) { generateRndSeq( rndseq1[i], nlen ); generateRndSeq( rndseq2[i], nlen ); } #endif localalloclen = nlen; } for( j=0; j<clus1; j++ ) strcpy( tmpseq1[j], seq1[j] ); for( j=0; j<clus2; j++ ) strcpy( tmpseq2[j], seq2[j] ); #if 0 fftfp = fopen( "input_of_Falign", "w" ); fprintf( fftfp, "nlen = %d\n", nlen ); fprintf( fftfp, "seq1: ( %d sequences ) \n", clus1 ); for( i=0; i<clus1; i++ ) fprintf( fftfp, "%s\n", seq1[i] ); fprintf( fftfp, "seq2: ( %d sequences ) \n", clus2 ); for( i=0; i<clus2; i++ ) fprintf( fftfp, "%s\n", seq2[i] ); fclose( fftfp ); system( "less input_of_Falign < /dev/tty > /dev/tty" ); #endif if( !kobetsubunkatsu ) { fprintf( stderr, "FFT ... " ); for( j=0; j<n20or4or2; j++ ) vec_init( seqVector1[j], nlen ); if( fftscore && scoremtx != -1 ) { for( i=0; i<clus1; i++ ) { seq_vec_2( seqVector1[0], polarity, eff1[i], tmpseq1[i] ); seq_vec_2( seqVector1[1], volume, eff1[i], tmpseq1[i] ); } } else { #if 0 for( i=0; i<clus1; i++ ) for( j=0; j<n20or4or2; j++ ) seq_vec( seqVector1[j], amino[j], eff1[i], tmpseq1[i] ); #else for( i=0; i<clus1; i++ ) seq_vec_3( seqVector1, eff1[i], tmpseq1[i] ); #endif } #if RND for( i=0; i<clus1; i++ ) { vec_init2( seqVector1, rndseq1[i], eff1[i], len1, nlen ); } #endif #if 0 fftfp = fopen( "seqVec", "w" ); fprintf( fftfp, "before transform\n" ); for( k=0; k<n20or4or2; k++ ) { fprintf( fftfp, "nlen=%d\n", nlen ); fprintf( fftfp, "%c\n", amino[k] ); for( l=0; l<nlen; l++ ) fprintf( fftfp, "%f %f\n", seqVector1[k][l].R, seqVector1[k][l].I ); } fclose( fftfp ); system( "less seqVec < /dev/tty > /dev/tty" ); #endif for( j=0; j<n20or4or2; j++ ) vec_init( seqVector2[j], nlen ); if( fftscore && scoremtx != -1 ) { for( i=0; i<clus2; i++ ) { seq_vec_2( seqVector2[0], polarity, eff2[i], tmpseq2[i] ); seq_vec_2( seqVector2[1], volume, eff2[i], tmpseq2[i] ); } } else { #if 0 for( i=0; i<clus2; i++ ) for( j=0; j<n20or4or2; j++ ) seq_vec( seqVector2[j], amino[j], eff2[i], tmpseq2[i] ); #else for( i=0; i<clus2; i++ ) seq_vec_3( seqVector2, eff2[i], tmpseq2[i] ); #endif } #if RND for( i=0; i<clus2; i++ ) { vec_init2( seqVector2, rndseq2[i], eff2[i], len2, nlen ); } #endif #if 0 fftfp = fopen( "seqVec2", "w" ); fprintf( fftfp, "before fft\n" ); for( k=0; k<n20or4or2; k++ ) { fprintf( fftfp, "%c\n", amino[k] ); for( l=0; l<nlen; l++ ) fprintf( fftfp, "%f %f\n", seqVector2[k][l].R, seqVector2[k][l].I ); } fclose( fftfp ); system( "less seqVec2 < /dev/tty > /dev/tty" ); #endif for( j=0; j<n20or4or2; j++ ) { fft( nlen, seqVector2[j], (j==0) ); fft( nlen, seqVector1[j], 0 ); } #if 0 fftfp = fopen( "seqVec2", "w" ); fprintf( fftfp, "#after fft\n" ); for( k=0; k<n20or4or2; k++ ) { fprintf( fftfp, "#%c\n", amino[k] ); for( l=0; l<nlen; l++ ) fprintf( fftfp, "%f %f\n", seqVector2[k][l].R, seqVector2[k][l].I ); } fclose( fftfp ); system( "less seqVec2 < /dev/tty > /dev/tty" ); #endif for( k=0; k<n20or4or2; k++ ) { for( l=0; l<nlen; l++ ) calcNaiseki( naiseki[k]+l, seqVector1[k]+l, seqVector2[k]+l ); } for( l=0; l<nlen; l++ ) { naisekiNoWa[l].R = 0.0; naisekiNoWa[l].I = 0.0; for( k=0; k<n20or4or2; k++ ) { naisekiNoWa[l].R += naiseki[k][l].R; naisekiNoWa[l].I += naiseki[k][l].I; } } #if 0 fftfp = fopen( "naisekiNoWa", "w" ); fprintf( fftfp, "#Before fft\n" ); for( l=0; l<nlen; l++ ) fprintf( fftfp, "%d %f %f\n", l, naisekiNoWa[l].R, naisekiNoWa[l].I ); fclose( fftfp ); system( "less naisekiNoWa < /dev/tty > /dev/tty " ); #endif fft( -nlen, naisekiNoWa, 0 ); for( m=0; m<=nlen2; m++ ) soukan[m] = naisekiNoWa[nlen2-m].R; for( m=nlen2+1; m<nlen; m++ ) soukan[m] = naisekiNoWa[nlen+nlen2-m].R; #if 0 fftfp = fopen( "naisekiNoWa", "w" ); fprintf( fftfp, "#After fft\n" ); for( l=0; l<nlen; l++ ) fprintf( fftfp, "%d %f\n", l, naisekiNoWa[l].R ); fclose( fftfp ); fftfp = fopen( "list.plot", "w" ); fprintf( fftfp, "plot 'naisekiNoWa'\npause -1" ); fclose( fftfp ); system( "/usr/bin/gnuplot list.plot &" ); #endif #if 0 fprintf( stderr, "frt write start\n" ); fftfp = fopen( "frt", "w" ); for( l=0; l<nlen; l++ ) fprintf( fftfp, "%d %f\n", l-nlen2, soukan[l] ); fclose( fftfp ); system( "less frt < /dev/tty > /dev/tty" ); #if 0 fftfp = fopen( "list.plot", "w" ); fprintf( fftfp, "plot 'frt'\n pause +1" ); fclose( fftfp ); system( "/usr/bin/gnuplot list.plot" ); #endif #endif getKouho( kouho, NKOUHO, soukan, nlen ); #if 0 for( i=0; i<NKOUHO; i++ ) { fprintf( stderr, "kouho[%d] = %d\n", i, kouho[i] ); } #endif } #if KEIKA fprintf( stderr, "Searching anchors ... " ); #endif count = 0; #define CAND 0 #if CAND fftfp = fopen( "cand", "w" ); fclose( fftfp ); #endif if( kobetsubunkatsu ) { maxk = 1; kouho[0] = 0; } else { maxk = NKOUHO; } for( k=0; k<maxk; k++ ) { lag = kouho[k]; zurasu2( lag, clus1, clus2, seq1, seq2, tmpptr1, tmpptr2 ); #if CAND fftfp = fopen( "cand", "a" ); fprintf( fftfp, "Candidate No.%d lag = %d\n", k+1, lag ); fprintf( fftfp, "%s\n", tmpptr1[0] ); fprintf( fftfp, "%s\n", tmpptr2[0] ); fclose( fftfp ); #endif tmpint = alignableReagion( clus1, clus2, tmpptr1, tmpptr2, eff1, eff2, segment+count ); if( count+tmpint > MAXSEG -3 ) ErrorExit( "TOO MANY SEGMENTS.\n" ); while( tmpint-- > 0 ) { if( lag > 0 ) { segment1[count].start = segment[count].start ; segment1[count].end = segment[count].end ; segment1[count].center = segment[count].center; segment1[count].score = segment[count].score; segment2[count].start = segment[count].start + lag; segment2[count].end = segment[count].end + lag; segment2[count].center = segment[count].center + lag; segment2[count].score = segment[count].score ; } else { segment1[count].start = segment[count].start - lag; segment1[count].end = segment[count].end - lag; segment1[count].center = segment[count].center - lag; segment1[count].score = segment[count].score ; segment2[count].start = segment[count].start ; segment2[count].end = segment[count].end ; segment2[count].center = segment[count].center; segment2[count].score = segment[count].score ; } #if 0 fftfp = fopen( "cand", "a" ); fprintf( fftfp, "Goukaku=%dko\n", tmpint ); fprintf( fftfp, "in 1 %d\n", segment1[count].center ); fprintf( fftfp, "in 2 %d\n", segment2[count].center ); fclose( fftfp ); #endif segment1[count].pair = &segment2[count]; segment2[count].pair = &segment1[count]; count++; #if 0 fprintf( stderr, "count=%d\n", count ); #endif } } #if 1 if( !kobetsubunkatsu ) fprintf( stderr, "%d segments found\n", count ); #endif if( !count && fftNoAnchStop ) ErrorExit( "Cannot detect anchor!" ); #if 0 fftfp = fopen( "fft", "a" ); fprintf( fftfp, "RESULT before sort:\n" ); for( l=0; l<count; l++ ) { fprintf( fftfp, "cut[%d]=%d, ", l, segment1[l].center ); fprintf( fftfp, "%d score = %f\n", segment2[l].center, segment1[l].score ); } fclose( fftfp ); #endif #if KEIKA fprintf( stderr, "Aligning anchors ... " ); #endif for( i=0; i<count; i++ ) { sortedseg1[i] = &segment1[i]; sortedseg2[i] = &segment2[i]; } #if 0 tmpsort( count, sortedseg1 ); tmpsort( count, sortedseg2 ); qsort( sortedseg1, count, sizeof( Segment * ), segcmp ); qsort( sortedseg2, count, sizeof( Segment * ), segcmp ); #else mymergesort( 0, count-1, sortedseg1 ); mymergesort( 0, count-1, sortedseg2 ); #endif for( i=0; i<count; i++ ) sortedseg1[i]->number = i; for( i=0; i<count; i++ ) sortedseg2[i]->number = i; if( kobetsubunkatsu ) { for( i=0; i<count; i++ ) { cut1[i+1] = sortedseg1[i]->center; cut2[i+1] = sortedseg2[i]->center; } cut1[0] = 0; cut2[0] = 0; cut1[count+1] = len1; cut2[count+1] = len2; count += 2; } else { if( crossscoresize < count+2 ) { crossscoresize = count+2; #if 1 fprintf( stderr, "######allocating crossscore, size = %d\n", crossscoresize ); #endif if( crossscore ) FreeDoubleMtx( crossscore ); crossscore = AllocateDoubleMtx( crossscoresize, crossscoresize ); } for( i=0; i<count+2; i++ ) for( j=0; j<count+2; j++ ) crossscore[i][j] = 0.0; for( i=0; i<count; i++ ) { crossscore[segment1[i].number+1][segment1[i].pair->number+1] = segment1[i].score; cut1[i+1] = sortedseg1[i]->center; cut2[i+1] = sortedseg2[i]->center; } #if DEBUG fprintf( stderr, "AFTER SORT\n" ); for( i=0; i<count; i++ ) fprintf( stderr, "%d, %d\n", segment1[i].start, segment2[i].start ); #endif crossscore[0][0] = 10000000.0; cut1[0] = 0; cut2[0] = 0; crossscore[count+1][count+1] = 10000000.0; cut1[count+1] = len1; cut2[count+1] = len2; count += 2; count0 = count; blockAlign2( cut1, cut2, sortedseg1, sortedseg2, crossscore, &count ); if( count0 > count ) { #if 0 fprintf( stderr, "\7 REPEAT!? \n" ); #else fprintf( stderr, "REPEAT!? \n" ); #endif if( fftRepeatStop ) exit( 1 ); } #if KEIKA else fprintf( stderr, "done\n" ); #endif } #if 0 fftfp = fopen( "fft", "a" ); fprintf( fftfp, "RESULT after sort:\n" ); for( l=0; l<count; l++ ) { fprintf( fftfp, "cut[%d]=%d, ", l, segment1[l].center ); fprintf( fftfp, "%d\n", segment2[l].center ); } fclose( fftfp ); #endif #if 0 fftfp = fopen( "fft", "a" ); fprintf( fftfp, "RESULT after sort:\n" ); for( l=0; l<count; l++ ) { fprintf( fftfp, "cut : %d %d\n", cut1[l], cut2[l] ); } fclose( fftfp ); #endif #if KEIKA fprintf( trap_g, "Devided to %d segments\n", count-1 ); fprintf( trap_g, "%d %d forg\n", MIN( clus1, clus2 ), count-1 ); #endif totallen = 0; for( j=0; j<clus1; j++ ) result1[j][0] = 0; for( j=0; j<clus2; j++ ) result2[j][0] = 0; totalscore = 0.0; *totalimpmatch = 0.0; for( i=0; i<count-1; i++ ) { #if DEBUG fprintf( stderr, "DP %03d / %03d %4d to ", i+1, count-1, totallen ); #else #if KEIKA fprintf( stderr, "DP %03d / %03d\r", i+1, count-1 ); #endif #endif if( cut1[i] ) { getkyokaigap( sgap1, seq1, cut1[i]-1, clus1 ); getkyokaigap( sgap2, seq2, cut2[i]-1, clus2 ); } else { for( j=0; j<clus1; j++ ) sgap1[j] = 'o'; for( j=0; j<clus2; j++ ) sgap2[j] = 'o'; } if( cut1[i+1] != len1 ) { getkyokaigap( egap1, seq1, cut1[i+1], clus1 ); getkyokaigap( egap2, seq2, cut2[i+1], clus2 ); } else { for( j=0; j<clus1; j++ ) egap1[j] = 'o'; for( j=0; j<clus2; j++ ) egap2[j] = 'o'; } for( j=0; j<clus1; j++ ) { strncpy( tmpres1[j], seq1[j]+cut1[i], cut1[i+1]-cut1[i] ); tmpres1[j][cut1[i+1]-cut1[i]] = 0; } if( kobetsubunkatsu ) commongappick_record( clus1, tmpres1, gapmap1 ); for( j=0; j<clus2; j++ ) { strncpy( tmpres2[j], seq2[j]+cut2[i], cut2[i+1]-cut2[i] ); tmpres2[j][cut2[i+1]-cut2[i]] = 0; } if( kobetsubunkatsu ) commongappick_record( clus2, tmpres2, gapmap2 ); #if 0 fprintf( stderr, "count = %d\n", count ); fprintf( stderr, "### reg1 = %d-%d\n", cut1[i], cut1[i+1]-1 ); fprintf( stderr, "### reg2 = %d-%d\n", cut2[i], cut2[i+1]-1 ); #endif switch( alg ) { case( 'a' ): totalscore += Aalign( tmpres1, tmpres2, eff1, eff2, clus1, clus2, alloclen ); break; case( 'Q' ): totalscore += partQ__align( tmpres1, tmpres2, eff1, eff2, clus1, clus2, alloclen, localhom, &impmatch, cut1[i], cut1[i+1]-1, cut2[i], cut2[i+1]-1, gapmap1, gapmap2, sgap1, sgap2, egap1, egap2 ); *totalimpmatch += impmatch; // fprintf( stderr, "*totalimpmatch in Falign_localhom = %f\n", *totalimpmatch ); break; case( 'A' ): totalscore += partA__align( tmpres1, tmpres2, eff1, eff2, clus1, clus2, alloclen, localhom, &impmatch, cut1[i], cut1[i+1]-1, cut2[i], cut2[i+1]-1, gapmap1, gapmap2, sgap1, sgap2, egap1, egap2, chudanpt, chudanref, chudanres ); *totalimpmatch += impmatch; // fprintf( stderr, "*totalimpmatch in Falign_localhom = %f\n", *totalimpmatch ); break; default: fprintf( stderr, "alg = %c\n", alg ); ErrorExit( "ERROR IN SOURCE FILE Falign.c" ); break; } #ifdef enablemultithread if( chudanres && *chudanres ) { // fprintf( stderr, "\n\n## CHUUDAN!!! at Falign_localhom\n" ); return( -1.0 ); } #endif nlen = strlen( tmpres1[0] ); if( totallen + nlen > alloclen ) { fprintf( stderr, "totallen=%d + nlen=%d > alloclen = %d\n", totallen, nlen, alloclen ); ErrorExit( "LENGTH OVER in Falign\n " ); } for( j=0; j<clus1; j++ ) strcat( result1[j], tmpres1[j] ); for( j=0; j<clus2; j++ ) strcat( result2[j], tmpres2[j] ); totallen += nlen; #if 0 fprintf( stderr, "%4d\r", totallen ); fprintf( stderr, "\n\n" ); for( j=0; j<clus1; j++ ) { fprintf( stderr, "%s\n", tmpres1[j] ); } fprintf( stderr, "-------\n" ); for( j=0; j<clus2; j++ ) { fprintf( stderr, "%s\n", tmpres2[j] ); } #endif } #if KEIKA fprintf( stderr, "DP ... done \n" ); #endif for( j=0; j<clus1; j++ ) strcpy( seq1[j], result1[j] ); for( j=0; j<clus2; j++ ) strcpy( seq2[j], result2[j] ); #if 0 for( j=0; j<clus1; j++ ) { fprintf( stderr, "%s\n", result1[j] ); } fprintf( stderr, "- - - - - - - - - - -\n" ); for( j=0; j<clus2; j++ ) { fprintf( stderr, "%s\n", result2[j] ); } #endif return( totalscore ); }
static int get_option(int argc, char *argv[]) { int nargs = 0 ; char *option ; option = argv[1] + 1 ; /* past '-' */ if (!stricmp(option, "-help")||!stricmp(option, "-usage")) { usage(1) ; } else if (!stricmp(option, "version")) { print_version() ; } else if (!stricmp(option, "abs")) { DoAbs = 1; } else if (!stricmp(option, "xform")) { xform_fname = argv[2]; nargs = 1; fprintf(stderr, "transform file name is %s\n", xform_fname); } else if (!stricmp(option, "T") || !stricmp(option, "threshold") ) { threshold = (float)atof(argv[2]); nargs = 1; fprintf(stderr, "threshold mask volume at %g\n", threshold); } else if (!stricmp(option, "BB")|| !stricmp(option, "boundingbox")) { nPadBB = (int)atoi(argv[2]); DoBB = 1; nargs = 1; printf("bounding box npad = %d\n",nPadBB); } else if (!stricmp(option, "transfer")) { do_transfer = 1; transfer_val = (float)atof(argv[2]); nargs = 1; fprintf(stderr, "transfer mask voxels=%g to dst vol\n", transfer_val); } else if (!stricmp(option, "invert")) { invert = 1; fprintf(stderr, "Inversely apply the given LTA transform\n"); } else if (!stricmp(option, "lta_src") || !stricmp(option, "src") ) { fprintf(stderr, "src volume for the given transform " "(given by -xform) is %s\n",argv[2]); fprintf(stderr, "Reading the src volume...\n"); lta_src = MRIreadHeader(argv[2], MRI_VOLUME_TYPE_UNKNOWN); if (!lta_src) { ErrorExit(ERROR_BADPARM, "Could not read file %s\n", argv[2]); } nargs = 1; } else if (!stricmp(option, "lta_dst") || !stricmp(option, "dst") ) { fprintf(stderr, "dst volume for the transform " "(given by -xform) is %s\n",argv[2]); fprintf(stderr, "Reading the dst volume...\n"); lta_dst = MRIreadHeader(argv[2], MRI_VOLUME_TYPE_UNKNOWN); if (!lta_dst) { ErrorExit(ERROR_BADPARM, "Could not read file %s\n", argv[2]); } nargs = 1; } else if (!stricmp(option, "keep_mask_deletion_edits")) { keep_mask_deletion_edits = 1; fprintf(stderr, "Transferring mask edits ('1' voxels) to dst vol\n"); } else { fprintf(stderr, "unknown option %s\n", argv[1]) ; usage(1) ; exit(1) ; } return(nargs) ; }
void JSBModule::Load(const String &moduleJSONFilename) { ResourceCache* cache = JSBind::context_->GetSubsystem<ResourceCache>(); JSONFile* moduleJSONFile = cache->GetResource<JSONFile>(moduleJSONFilename); if (!moduleJSONFile) { LOGERRORF("Couldn't load module json: %s", moduleJSONFilename.CString()); ErrorExit("Couldn't load module json"); } JSONValue moduleJSON = moduleJSONFile->GetRoot(); JSONValue sources = moduleJSON.GetChild("sources"); JSONValue classes = moduleJSON.GetChild("classes"); JSONValue includes = moduleJSON.GetChild("includes"); JSONValue classes_rename = moduleJSON.GetChild("classes_rename"); JSONValue overloads = moduleJSON.GetChild("overloads"); JSONValue requires = moduleJSON.GetChild("requires"); HashMap<String, String> rename; if (requires.IsArray()) { for (unsigned j = 0; j < requires.GetSize(); j++) { requirements_.Push(requires.GetString(j)); } } if (classes_rename.IsObject()) { Vector<String> childNames = classes_rename.GetValueNames(); for (unsigned j = 0; j < childNames.Size(); j++) { String classname = childNames.At(j); String crename = classes_rename.GetString(classname); rename[classname] = crename; } } if (includes.IsArray()) { for (unsigned j = 0; j < includes.GetSize(); j++) { includes_.Push(includes.GetString(j)); } } if (classes.IsArray()) { for (unsigned j = 0; j < classes.GetSize(); j++) { String classname = classes.GetString(j); if (rename.Contains(classname)) bindings_->RegisterClass(classname, rename[classname]); else bindings_->RegisterClass(classname); } } if (overloads.IsObject()) { Vector<String> childNames = overloads.GetChildNames(); for (unsigned j = 0; j < childNames.Size(); j++) { String classname = childNames.At(j); JSBClass* klass = bindings_->GetClass(classname); if (!klass) { ErrorExit("Bad overload klass"); } JSONValue classoverloads = overloads.GetChild(classname); Vector<String> functionNames = classoverloads.GetChildNames(); for (unsigned k = 0; k < functionNames.Size(); k++) { JSONValue sig = classoverloads.GetChild(functionNames[k]); if (!sig.IsArray()) { ErrorExit("Bad overload defintion"); } Vector<String> values; for (unsigned x = 0; x < sig.GetSize(); x++) { values.Push(sig.GetString(x)); } JSBFunctionOverride* fo = new JSBFunctionOverride(functionNames[k], values); klass->AddFunctionOverride(fo); } } } this->name_ = moduleJSON.GetString("name"); if (this->name_ == "Graphics") { #ifdef _MSC_VER if (JSBind::PLATFORM == "ANDROID" || JSBind::PLATFORM == "WEB") { sources.AddString("Graphics/OpenGL"); } else { sources.AddString("Graphics/Direct3D9"); } #else sources.AddString("Graphics/OpenGL"); #endif } for (unsigned j = 0; j < sources.GetSize(); j++) { String sourceFolder = sources.GetString(j); Vector<String> fileNames; String sourceRoot = "Atomic"; if (sourceFolder == "Javascript") sourceRoot = "AtomicJS"; JSBind::fileSystem_->ScanDir(fileNames, JSBind::ROOT_FOLDER + "/Source/" + sourceRoot + "/" + sourceFolder, "*.h", SCAN_FILES, false); for (unsigned k = 0; k < fileNames.Size(); k++) { // TODO: filter String filepath = JSBind::ROOT_FOLDER + "/Source/" + sourceRoot + "/" + sourceFolder + "/" + fileNames[k]; this->headerFiles_.Push(filepath); } } }
BOOL CreateWinGHCiMainWindow(INT nCmdShow) { //hWndMain = CreateDialog(hThisInstance, MAKEINTRESOURCE(DLG_MAIN), NULL, &MainWndProc); if (!RegisterWinGHCiWindowClass(hThisInstance) ) { ErrorExit(TEXT("Could not register WinGHCiWindowClass")); return FALSE; } hWndMain = CreateWindowEx(WS_EX_ACCEPTFILES,WinGHCiWindowClass, WinGHCiWindowTitle, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hThisInstance, NULL); if (!hWndMain) { ErrorExit(TEXT("CreateWinGHCiMainWindow")); return FALSE; } ShowWindow(hWndMain, nCmdShow); UpdateWindow(hWndMain); // Setup the icons SendMessage(hWndMain, WM_SETICON, ICON_SMALL, (LPARAM) LoadIcon(hThisInstance, MAKEINTRESOURCE(ID_GHCi_ICON))); SendMessage(hWndMain, WM_SETICON, ICON_BIG, (LPARAM) LoadIcon(hThisInstance, MAKEINTRESOURCE(ID_WinGHCi_ICON))); // Create status line hWndStatus = CreateWindowEx( 0, STATUSCLASSNAME, (LPCTSTR) TEXT(""), WS_CHILD | SBARS_SIZEGRIP | WS_VISIBLE, 0, 0, 0, 0, hWndMain, (HMENU) IDC_Statusbar, hThisInstance, NULL); // create rich edit control hWndRtf = CreateWindowEx( WS_EX_CLIENTEDGE, RICHEDIT_CLASS, (LPCTSTR) TEXT(""), WS_CHILD | WS_VISIBLE | WS_VSCROLL | ES_AUTOVSCROLL | ES_MULTILINE | ES_DISABLENOSCROLL | ES_WANTRETURN, 0, 0, 0, 0, hWndMain, (HMENU) IDC_Rtf, hThisInstance, NULL); RtfWindowInit(); SetFocus(hWndRtf); CreateToolbar(); InitMruFiles(); InitHistory(); RegistryReadWindowPos(hWndMain); return TRUE; }
int main(int argc, char *argv[]) { char *ref_fname, *in_fname, *out_fname, fname[STRLEN], **av ; MRI *mri_ref, *mri_in, *mri_orig, *mri_in_red, *mri_ref_red, *mri_in_tmp, *mri_ref_tmp, *mri_ref_orig, *mri_in_orig ; int ac, nargs, i, msec, minutes, seconds ; struct timeb start ; MATRIX *m_L ; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mri_linear_register.c,v 1.13 2011/03/02 00:04:22 nicks Exp $", "$Name: stable5 $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; parms.mri_crop = NULL ; parms.l_intensity = 1.0f ; parms.niterations = 100 ; parms.levels = -1 ; /* use default */ parms.dt = 1e-6 ; /* was 5e-6 */ parms.tol = INTEGRATION_TOL*5 ; parms.dt = 5e-6 ; /* was 5e-6 */ parms.tol = 1e-3 ; parms.momentum = 0.8 ; parms.max_levels = MAX_LEVELS ; parms.factor = 1.0 ; parms.niterations = 25 ; Progname = argv[0] ; DiagInit(NULL, NULL, NULL) ; ErrorInit(NULL, NULL, NULL) ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc < 4) ErrorExit(ERROR_BADPARM, "usage: %s <in brain> <template> <output file name>\n", Progname) ; in_fname = argv[1] ; ref_fname = argv[2] ; if (xform_mean_fname) { int sno, nsubjects ; FILE *fp ; parms.m_xform_mean = MatrixAsciiRead(xform_mean_fname, NULL) ; if (!parms.m_xform_mean) ErrorExit(Gerror, "%s: could not read parameter means from %s", Progname, xform_mean_fname) ; fp = fopen(xform_covariance_fname, "r") ; if (!fp) ErrorExit(ERROR_NOFILE, "%s: could not read covariances from %s", Progname, xform_covariance_fname) ; fscanf(fp, "nsubjects=%d", &nsubjects) ; printf("reading %d transforms...\n", nsubjects) ; parms.m_xforms = (MATRIX **)calloc(nsubjects, sizeof(MATRIX *)) ; if (!parms.m_xforms) ErrorExit(ERROR_NOMEMORY, "%s: could not allocate array of %d xforms", Progname, nsubjects) ; for (sno = 0 ; sno < nsubjects ; sno++) { parms.m_xforms[sno] = MatrixAsciiReadFrom(fp, NULL) ; if (!parms.m_xforms[sno]) ErrorExit(ERROR_NOMEMORY, "%s: could not allocate %dth xform", Progname, sno) ; } parms.m_xform_covariance = MatrixAsciiReadFrom(fp, NULL) ; if (!parms.m_xform_covariance) ErrorExit(Gerror, "%s: could not read parameter covariance from %s", Progname, xform_covariance_fname) ; fclose(fp) ; parms.l_priors = l_priors ; parms.nxforms = nsubjects ; } out_fname = argv[3] ; FileNameOnly(out_fname, fname) ; FileNameRemoveExtension(fname, fname) ; strcpy(parms.base_name, fname) ; fprintf(stderr, "logging results to %s.log\n", parms.base_name) ; TimerStart(&start) ; fprintf(stderr, "reading '%s'...\n", ref_fname) ; fflush(stderr) ; mri_ref = MRIread(ref_fname) ; if (!mri_ref) ErrorExit(ERROR_NOFILE, "%s: could not open reference volume %s.\n", Progname, ref_fname) ; if (mri_ref->type != MRI_UCHAR) { MRI *mri_tmp ; mri_tmp = MRIchangeType(mri_ref, MRI_UCHAR, 0.0, 0.999, FALSE) ; MRIfree(&mri_ref) ; mri_ref = mri_tmp ; } if (var_fname) /* read in a volume of standard deviations */ { MRI *mri_var, *mri_tmp ; fprintf(stderr, "reading '%s'...\n", var_fname) ; mri_var = MRIread(var_fname) ; if (!mri_var) ErrorExit(ERROR_NOFILE, "%s: could not open variance volume %s.\n", Progname, var_fname) ; mri_tmp = MRIconcatenateFrames(mri_ref, mri_var, NULL) ; MRIfree(&mri_var) ; MRIfree(&mri_ref) ; mri_ref = mri_tmp ; } fprintf(stderr, "reading '%s'...\n", in_fname) ; fflush(stderr) ; mri_orig = mri_in = MRIread(in_fname) ; if (!mri_in) ErrorExit(ERROR_NOFILE, "%s: could not open input volume %s.\n", Progname, in_fname) ; if (mri_in->type != MRI_UCHAR) { MRI *mri_tmp ; mri_orig = mri_tmp = MRIchangeType(mri_in, MRI_UCHAR, 0.0, 0.999, FALSE) ; MRIfree(&mri_in) ; mri_in = mri_tmp ; } /* make sure they are the same size */ if (mri_in->width != mri_ref->width || mri_in->height != mri_ref->height || mri_in->depth != mri_ref->depth) { int width, height, depth ; MRI *mri_tmp ; width = MAX(mri_in->width, mri_ref->width) ; height = MAX(mri_in->height, mri_ref->height) ; depth = MAX(mri_in->depth, mri_ref->depth) ; mri_tmp = MRIalloc(width, height, depth, MRI_UCHAR) ; MRIextractInto(mri_in, mri_tmp, 0, 0, 0, mri_in->width, mri_in->height, mri_in->depth, 0, 0, 0) ; #if 0 MRIfree(&mri_in) ; #else parms.mri_in = mri_in ; #endif mri_in = mri_orig = mri_tmp ; mri_tmp = MRIallocSequence(width, height,depth,MRI_UCHAR,mri_ref->nframes); MRIextractInto(mri_ref, mri_tmp, 0, 0, 0, mri_ref->width, mri_ref->height, mri_ref->depth, 0, 0, 0) ; #if 0 MRIfree(&mri_ref) ; #else parms.mri_in = mri_in ; #endif mri_ref = mri_tmp ; } if (!FZERO(tx) || !FZERO(ty) || !FZERO(tz)) { MRI *mri_tmp ; fprintf(stderr, "translating second volume by (%2.1f, %2.1f, %2.1f)\n", tx, ty, tz) ; mri_tmp = MRItranslate(mri_in, NULL, tx, ty, tz) ; MRIfree(&mri_in) ; mri_in = mri_tmp ; } if (!FZERO(rzrot)) { MRI *mri_tmp ; fprintf(stderr, "rotating second volume by %2.1f degrees around Z axis\n", (float)DEGREES(rzrot)) ; mri_tmp = MRIrotateZ_I(mri_in, NULL, rzrot) ; MRIfree(&mri_in) ; mri_in = mri_tmp ; } if (!FZERO(rxrot)) { MRI *mri_tmp ; fprintf(stderr, "rotating second volume by %2.1f degrees around X axis\n", (float)DEGREES(rxrot)) ; mri_tmp = MRIrotateX_I(mri_in, NULL, rxrot) ; MRIfree(&mri_in) ; mri_in = mri_tmp ; } if (!FZERO(ryrot)) { MRI *mri_tmp ; fprintf(stderr, "rotating second volume by %2.1f degrees around Y axis\n", (float)DEGREES(ryrot)) ; mri_tmp = MRIrotateY_I(mri_in, NULL, ryrot) ; MRIfree(&mri_in) ; mri_in = mri_tmp ; } if (!transform_loaded) /* wasn't preloaded */ parms.lta = LTAalloc(1, mri_in) ; if (!FZERO(blur_sigma)) { MRI *mri_kernel, *mri_tmp ; mri_kernel = MRIgaussian1d(blur_sigma, 100) ; mri_tmp = MRIconvolveGaussian(mri_in, NULL, mri_kernel) ; mri_in = mri_tmp ; MRIfree(&mri_kernel) ; } MRIscaleMeanIntensities(mri_in, mri_ref, mri_in); mri_ref_orig = mri_ref ; mri_in_orig = mri_in ; if (nreductions > 0) { mri_in_red = mri_in_tmp = MRIcopy(mri_in, NULL) ; mri_ref_red = mri_ref_tmp = MRIcopy(mri_ref, NULL) ; for (i = 0 ; i < nreductions ; i++) { mri_in_red = MRIreduceByte(mri_in_tmp, NULL) ; mri_ref_red = MRIreduceMeanAndStdByte(mri_ref_tmp,NULL); MRIfree(&mri_in_tmp); MRIfree(&mri_ref_tmp) ; mri_in_tmp = mri_in_red ; mri_ref_tmp = mri_ref_red ; } mri_in = mri_in_red ; mri_ref = mri_ref_red ; } /* for diagnostics */ if (full_res) { parms.mri_ref = mri_ref ; parms.mri_in = mri_in ; } else { parms.mri_ref = mri_ref_orig ; parms.mri_in = mri_in_orig ; } m_L = initialize_transform(mri_in, mri_ref, &parms) ; if (use_gradient) { MRI *mri_in_mag, *mri_ref_mag, *mri_grad, *mri_mag ; printf("computing gradient magnitude of input image...\n") ; mri_mag = MRIalloc(mri_in->width, mri_in->height, mri_in->depth,MRI_FLOAT); MRIcopyHeader(mri_in, mri_mag) ; mri_grad = MRIsobel(mri_in, NULL, mri_mag) ; MRIfree(&mri_grad) ; /* convert it to ubytes */ MRIvalScale(mri_mag, mri_mag, 0.0f, 255.0f) ; mri_in_mag = MRIclone(mri_in, NULL) ; MRIcopy(mri_mag, mri_in_mag) ; MRIfree(&mri_mag) ; /* now compute gradient of ref image */ printf("computing gradient magnitude of reference image...\n") ; mri_mag = MRIalloc(mri_ref->width, mri_ref->height, mri_ref->depth,MRI_FLOAT); MRIcopyHeader(mri_ref, mri_mag) ; mri_grad = MRIsobel(mri_ref, NULL, mri_mag) ; MRIfree(&mri_grad) ; /* convert it to ubytes */ MRIvalScale(mri_mag, mri_mag, 0.0f, 255.0f) ; mri_ref_mag = MRIclone(mri_ref, NULL) ; MRIcopy(mri_mag, mri_ref_mag) ; MRIfree(&mri_mag) ; register_mri(mri_in_mag, mri_ref_mag, &parms, m_L) ; MRIfree(&mri_in_mag) ; MRIfree(&mri_ref_mag) ; } register_mri(mri_in, mri_ref, &parms, m_L) ; if (check_crop_flag) /* not working yet! */ { printf("searching for cropped regions in the input image...\n") ; parms.mri_crop = find_cropping(mri_orig, mri_ref, &parms) ; MRIwrite(parms.mri_crop, "crop.mgh") ; register_mri(mri_in, mri_ref, &parms, m_L) ; } if (voxel_coords) { printf("transforming xform to voxel coordinates...\n") ; MRIrasXformToVoxelXform(mri_in_orig, mri_ref_orig, parms.lta->xforms[0].m_L, parms.lta->xforms[0].m_L); if (Gdiag & DIAG_WRITE) { MRI *mri_tmp ; mri_tmp = MRIlinearTransform(mri_in_orig, NULL,parms.lta->xforms[0].m_L); MRIwriteImageViews(mri_tmp, "morphed", IMAGE_SIZE) ; MRIfree(&mri_tmp) ; } } // save src and target info in lta getVolGeom(mri_in_orig, &parms.lta->xforms[0].src); getVolGeom(mri_ref_orig, &parms.lta->xforms[0].dst); fprintf(stderr, "writing output transformation to %s...\n", out_fname) ; if (invert_flag) { MATRIX *m_tmp ; m_tmp = MatrixInverse(parms.lta->xforms[0].m_L, NULL) ; MatrixFree(&parms.lta->xforms[0].m_L) ; // change src and dst getVolGeom(mri_in_orig, &parms.lta->xforms[0].dst); getVolGeom(mri_ref_orig, &parms.lta->xforms[0].src); parms.lta->xforms[0].m_L = m_tmp ; } // LTAwriteEx(parms.lta, out_fname) ; // if (mri_ref) MRIfree(&mri_ref) ; if (mri_in) MRIfree(&mri_in) ; msec = TimerStop(&start) ; seconds = nint((float)msec/1000.0f) ; minutes = seconds / 60 ; seconds = seconds % 60 ; fprintf(stderr, "registration took %d minutes and %d seconds.\n", minutes, seconds) ; exit(0) ; return(0) ; }
/*---------------------------------------------------------------------- Parameters: Description: ----------------------------------------------------------------------*/ static int get_option(int argc, char *argv[]) { int nargs = 0 ; char *option ; option = argv[1] + 1 ; /* past '-' */ StrUpper(option) ; if (!stricmp(option, "DIST") || !stricmp(option, "DISTANCE")) { parms.l_dist = atof(argv[2]) ; nargs = 1 ; fprintf(stderr, "l_dist = %2.2f\n", parms.l_dist) ; } else if (!stricmp(option, "DT")) { parms.dt = atof(argv[2]) ; nargs = 1 ; fprintf(stderr, "dt = %2.2e\n", parms.dt) ; } else if (!stricmp(option, "INVERT")) { invert_flag = 1 ; fprintf(stderr, "inverting transform before writing...\n") ; } else if (!stricmp(option, "crop")) { check_crop_flag = 1 ; nargs = 1 ; fprintf(stderr, "checking for cropping....\n") ; } else if (!stricmp(option, "nlevels")) { parms.max_levels = atoi(argv[2]) ; nargs = 1 ; fprintf(stderr, "nlevels = %d\n", parms.max_levels) ; } else if (!stricmp(option, "image_size")) { IMAGE_SIZE = atoi(argv[2]) ; nargs = 1 ; fprintf(stderr, "setting default image size to %d\n", IMAGE_SIZE) ; } else if (!stricmp(option, "TOL")) { parms.tol = atof(argv[2]) ; nargs = 1 ; fprintf(stderr, "tol = %2.2e\n", parms.tol) ; } else if (!stricmp(option, "NUM")) { num_xforms = atoi(argv[2]) ; nargs = 1 ; fprintf(stderr, "finding a total of %d linear transforms\n", num_xforms) ; } else if (!stricmp(option, "SCOUT")) { parms.scout_flag = 1 ; printf("limitting domain of integration to central slices...\n") ; } else if (!stricmp(option, "AREA")) { parms.l_area = atof(argv[2]) ; nargs = 1 ; fprintf(stderr, "l_area = %2.2f\n", parms.l_area) ; } else if (!stricmp(option, "WINDOW")) { window_size = atof(argv[2]) ; fprintf(stderr, "applying Hanning window (R=%2.1f) to images...\n", window_size) ; nargs = 1 ; } else if (!stricmp(option, "NLAREA")) { parms.l_nlarea = atof(argv[2]) ; nargs = 1 ; fprintf(stderr, "l_nlarea = %2.2f\n", parms.l_nlarea) ; } else if (!stricmp(option, "LEVELS")) { parms.levels = atoi(argv[2]) ; nargs = 1 ; fprintf(stderr, "levels = %d\n", parms.levels) ; } else if (!stricmp(option, "INTENSITY") || !stricmp(option, "CORR")) { parms.l_intensity = atof(argv[2]) ; nargs = 1 ; fprintf(stderr, "l_intensity = %2.2f\n", parms.l_intensity) ; } else if (!stricmp(option, "thresh")) { thresh_low = atoi(argv[2]) ; #if 1 fprintf(stderr, "setting threshold to %d\n", thresh_low) ; nargs = 1 ; #else thresh_hi = atoi(argv[3]) ; fprintf(stderr, "thresholds set to %d --> %d\n", thresh_low, thresh_hi) ; nargs = 2 ; #endif } else if (!stricmp(option, "reduce")) { nreductions = atoi(argv[2]) ; nargs = 1 ; fprintf(stderr, "reducing input images %d times before aligning...\n", nreductions) ; } else if (!stricmp(option, "priors")) { l_priors = atof(argv[2]) ; nargs = 1 ; fprintf(stderr, "using %2.2f as weight for prior term\n", l_priors) ; } else if (!stricmp(option, "voxel")) { voxel_coords = 1 ; fprintf(stderr, "outputting transform in voxel coordinates\n") ; } else if (!stricmp(option, "full_res")) { full_res = 1 ; fprintf(stderr, "outputting full resolution images\n") ; } else if (!stricmp(option, "nopca")) { nopca = 1 ; fprintf(stderr, "disabling pca\n") ; } else if (!stricmp(option, "factor")) { parms.factor = atof(argv[2]) ; nargs = 1 ; fprintf(stderr, "using time step factor of %2.2f\n",parms.factor) ; } else switch (*option) { case 'X': xform_mean_fname = argv[2] ; xform_covariance_fname = argv[3] ; printf("reading means (%s) and covariances (%s) of xforms\n", xform_mean_fname, xform_covariance_fname) ; nargs = 2 ; break ; case 'D': tx = atof(argv[2]) ; ty = atof(argv[3]) ; tz = atof(argv[4]) ; nargs = 3 ; break ; case 'R': rxrot = RADIANS(atof(argv[2])) ; ryrot = RADIANS(atof(argv[3])) ; rzrot = RADIANS(atof(argv[4])) ; nargs = 3 ; break ; case 'T': parms.lta = LTAread(argv[2]) ; if (!parms.lta) ErrorExit(ERROR_BADFILE, "%s: could not read transform file %s", Progname, argv[2]) ; nargs = 1 ; fprintf(stderr, "using previously computed transform %s\n", argv[2]) ; transform_loaded = 1 ; break ; case 'B': blur_sigma = atof(argv[2]) ; nargs = 1 ; fprintf(stderr, "blurring input image with sigma=%2.3f\n", blur_sigma); break ; case 'S': parms.sigma = atof(argv[2]) ; fprintf(stderr, "using sigma=%2.3f as upper bound on blurring.\n", parms.sigma) ; nargs = 1 ; break ; case '?': case 'U': printf("usage: %s <in volume> <template volume> <output transform>\n", argv[0]) ; exit(1) ; break ; case 'V': var_fname = argv[2] ; fprintf(stderr, "reading variance image from %s...\n", var_fname) ; nargs = 1 ; break ; case 'N': parms.niterations = atoi(argv[2]) ; nargs = 1 ; fprintf(stderr, "niterations = %d\n", parms.niterations) ; break ; case 'W': parms.write_iterations = atoi(argv[2]) ; nargs = 1 ; fprintf(stderr, "write iterations = %d\n", parms.write_iterations) ; Gdiag |= DIAG_WRITE ; break ; case 'M': parms.momentum = atof(argv[2]) ; nargs = 1 ; fprintf(stderr, "momentum = %2.2f\n", parms.momentum) ; break ; default: fprintf(stderr, "unknown option %s\n", argv[1]) ; exit(1) ; break ; } return(nargs) ; }
void Run(const Vector<String>& arguments) { if (arguments.Size() < 2) { ErrorExit( "Usage: OgreImporter <input file> <output file> [options]\n\n" "Options:\n" "-l Output a material list file\n" "-na Do not output animations\n" "-nm Do not output morphs\n" "-r Output only rotations from animations\n" "-s Split each submesh into own vertex buffer\n" "-t Generate tangents\n" "-mb <x> Maximum number of bones per submesh, default 64\n" ); } bool generateTangents = false; bool splitSubMeshes = false; bool exportAnimations = true; bool exportMorphs = true; bool rotationsOnly = false; bool saveMaterialList = false; if (arguments.Size() > 2) { for (unsigned i = 2; i < arguments.Size(); ++i) { if (arguments[i].Length() > 1 && arguments[i][0] == '-') { String argument = arguments[i].Substring(1).ToLower(); if (argument == "l") saveMaterialList = true; else if (argument == "r") rotationsOnly = true; else if (argument == "s") splitSubMeshes = true; else if (argument == "t") generateTangents = true; else if (argument.Length() == 2 && argument[0] == 'n') { switch (tolower(argument[1])) { case 'a': exportAnimations = false; break; case 'm': exportMorphs = false; break; } break; } else if (argument == "mb" && i < arguments.Size() - 1) { maxBones_ = ToUInt(arguments[i + 1]); if (maxBones_ < 1) maxBones_ = 1; ++i; } } } } LoadMesh(arguments[0], generateTangents, splitSubMeshes, exportMorphs); WriteOutput(arguments[1], exportAnimations, rotationsOnly, saveMaterialList); PrintLine("Finished"); }
void WriteOutput(const String& outputFileName, bool exportAnimations, bool rotationsOnly, bool saveMaterialList) { // Begin serialization { File dest(context_); if (!dest.Open(outputFileName, FILE_WRITE)) ErrorExit("Could not open output file " + outputFileName); // ID dest.WriteFileID("UMDL"); // Vertexbuffers dest.WriteUInt(vertexBuffers_.Size()); for (unsigned i = 0; i < vertexBuffers_.Size(); ++i) vertexBuffers_[i].WriteData(dest); // Indexbuffers dest.WriteUInt(indexBuffers_.Size()); for (unsigned i = 0; i < indexBuffers_.Size(); ++i) indexBuffers_[i].WriteData(dest); // Subgeometries dest.WriteUInt(subGeometries_.Size()); for (unsigned i = 0; i < subGeometries_.Size(); ++i) { // Write bone mapping info from the first LOD level. It does not change for further LODs dest.WriteUInt(subGeometries_[i][0].boneMapping_.Size()); for (unsigned k = 0; k < subGeometries_[i][0].boneMapping_.Size(); ++k) dest.WriteUInt(subGeometries_[i][0].boneMapping_[k]); // Lod levels for this subgeometry dest.WriteUInt(subGeometries_[i].Size()); for (unsigned j = 0; j < subGeometries_[i].Size(); ++j) { dest.WriteFloat(subGeometries_[i][j].distance_); dest.WriteUInt((unsigned)subGeometries_[i][j].primitiveType_); dest.WriteUInt(subGeometries_[i][j].vertexBuffer_); dest.WriteUInt(subGeometries_[i][j].indexBuffer_); dest.WriteUInt(subGeometries_[i][j].indexStart_); dest.WriteUInt(subGeometries_[i][j].indexCount_); } } // Morphs dest.WriteUInt(morphs_.Size()); for (unsigned i = 0; i < morphs_.Size(); ++i) morphs_[i].WriteData(dest); // Skeleton dest.WriteUInt(bones_.Size()); for (unsigned i = 0; i < bones_.Size(); ++i) { dest.WriteString(bones_[i].name_); dest.WriteUInt(bones_[i].parentIndex_); dest.WriteVector3(bones_[i].bindPosition_); dest.WriteQuaternion(bones_[i].bindRotation_); dest.WriteVector3(bones_[i].bindScale_); Matrix3x4 offsetMatrix(bones_[i].derivedPosition_, bones_[i].derivedRotation_, bones_[i].derivedScale_); offsetMatrix = offsetMatrix.Inverse(); dest.Write(offsetMatrix.Data(), sizeof(Matrix3x4)); dest.WriteUByte(bones_[i].collisionMask_); if (bones_[i].collisionMask_ & 1) dest.WriteFloat(bones_[i].radius_); if (bones_[i].collisionMask_ & 2) dest.WriteBoundingBox(bones_[i].boundingBox_); } // Bounding box dest.WriteBoundingBox(boundingBox_); // Geometry centers for (unsigned i = 0; i < subGeometryCenters_.Size(); ++i) dest.WriteVector3(subGeometryCenters_[i]); } if (saveMaterialList) { String materialListName = ReplaceExtension(outputFileName, ".txt"); File listFile(context_); if (listFile.Open(materialListName, FILE_WRITE)) { for (unsigned i = 0; i < materialNames_.Size(); ++i) { // Assume the materials will be located inside the standard Materials subdirectory listFile.WriteLine("Materials/" + ReplaceExtension(SanitateAssetName(materialNames_[i]), ".xml")); } } else PrintLine("Warning: could not write material list file " + materialListName); } XMLElement skeletonRoot = skelFile_->GetRoot("skeleton"); if (skeletonRoot && exportAnimations) { // Go through animations XMLElement animationsRoot = skeletonRoot.GetChild("animations"); if (animationsRoot) { XMLElement animation = animationsRoot.GetChild("animation"); while (animation) { ModelAnimation newAnimation; newAnimation.name_ = animation.GetAttribute("name"); newAnimation.length_ = animation.GetFloat("length"); XMLElement tracksRoot = animation.GetChild("tracks"); XMLElement track = tracksRoot.GetChild("track"); while (track) { String trackName = track.GetAttribute("bone"); ModelBone* bone = 0; for (unsigned i = 0; i < bones_.Size(); ++i) { if (bones_[i].name_ == trackName) { bone = &bones_[i]; break; } } if (!bone) ErrorExit("Found animation track for unknown bone " + trackName); AnimationTrack newAnimationTrack; newAnimationTrack.name_ = trackName; if (!rotationsOnly) newAnimationTrack.channelMask_ = CHANNEL_POSITION | CHANNEL_ROTATION; else newAnimationTrack.channelMask_ = CHANNEL_ROTATION; XMLElement keyFramesRoot = track.GetChild("keyframes"); XMLElement keyFrame = keyFramesRoot.GetChild("keyframe"); while (keyFrame) { AnimationKeyFrame newKeyFrame; // Convert from right- to left-handed XMLElement position = keyFrame.GetChild("translate"); float x = position.GetFloat("x"); float y = position.GetFloat("y"); float z = position.GetFloat("z"); Vector3 pos(x, y, -z); XMLElement rotation = keyFrame.GetChild("rotate"); XMLElement axis = rotation.GetChild("axis"); float angle = -rotation.GetFloat("angle") * M_RADTODEG; x = axis.GetFloat("x"); y = axis.GetFloat("y"); z = axis.GetFloat("z"); Vector3 axisVec(x, y, -z); Quaternion rot(angle, axisVec); // Transform from bind-pose relative into absolute pos = bone->bindPosition_ + pos; rot = bone->bindRotation_ * rot; newKeyFrame.time_ = keyFrame.GetFloat("time"); newKeyFrame.position_ = pos; newKeyFrame.rotation_ = rot; newAnimationTrack.keyFrames_.Push(newKeyFrame); keyFrame = keyFrame.GetNext("keyframe"); } // Make sure keyframes are sorted from beginning to end Sort(newAnimationTrack.keyFrames_.Begin(), newAnimationTrack.keyFrames_.End(), CompareKeyFrames); // Do not add tracks with no keyframes if (newAnimationTrack.keyFrames_.Size()) newAnimation.tracks_.Push(newAnimationTrack); track = track.GetNext("track"); } // Write each animation into a separate file String animationFileName = outputFileName.Replaced(".mdl", ""); animationFileName += "_" + newAnimation.name_ + ".ani"; File dest(context_); if (!dest.Open(animationFileName, FILE_WRITE)) ErrorExit("Could not open output file " + animationFileName); dest.WriteFileID("UANI"); dest.WriteString(newAnimation.name_); dest.WriteFloat(newAnimation.length_); dest.WriteUInt(newAnimation.tracks_.Size()); for (unsigned i = 0; i < newAnimation.tracks_.Size(); ++i) { AnimationTrack& track = newAnimation.tracks_[i]; dest.WriteString(track.name_); dest.WriteUByte(track.channelMask_); dest.WriteUInt(track.keyFrames_.Size()); for (unsigned j = 0; j < track.keyFrames_.Size(); ++j) { AnimationKeyFrame& keyFrame = track.keyFrames_[j]; dest.WriteFloat(keyFrame.time_); if (track.channelMask_ & CHANNEL_POSITION) dest.WriteVector3(keyFrame.position_); if (track.channelMask_ & CHANNEL_ROTATION) dest.WriteQuaternion(keyFrame.rotation_); if (track.channelMask_ & CHANNEL_SCALE) dest.WriteVector3(keyFrame.scale_); } } animation = animation.GetNext("animation"); PrintLine("Processed animation " + newAnimation.name_); } } } }
void LoadMesh(const String& inputFileName, bool generateTangents, bool splitSubMeshes, bool exportMorphs) { File meshFileSource(context_); meshFileSource.Open(inputFileName); if (!meshFile_->Load(meshFileSource)) ErrorExit("Could not load input file " + inputFileName); XMLElement root = meshFile_->GetRoot("mesh"); XMLElement subMeshes = root.GetChild("submeshes"); XMLElement skeletonLink = root.GetChild("skeletonlink"); if (root.IsNull()) ErrorExit("Could not load input file " + inputFileName); String skeletonName = skeletonLink.GetAttribute("name"); if (!skeletonName.Empty()) LoadSkeleton(GetPath(inputFileName) + GetFileName(skeletonName) + ".skeleton.xml"); // Check whether there's benefit of avoiding 32bit indices by splitting each submesh into own buffer XMLElement subMesh = subMeshes.GetChild("submesh"); unsigned totalVertices = 0; unsigned maxSubMeshVertices = 0; while (subMesh) { materialNames_.Push(subMesh.GetAttribute("material")); XMLElement geometry = subMesh.GetChild("geometry"); if (geometry) { unsigned vertices = geometry.GetInt("vertexcount"); totalVertices += vertices; if (maxSubMeshVertices < vertices) maxSubMeshVertices = vertices; } ++numSubMeshes_; subMesh = subMesh.GetNext("submesh"); } XMLElement sharedGeometry = root.GetChild("sharedgeometry"); if (sharedGeometry) { unsigned vertices = sharedGeometry.GetInt("vertexcount"); totalVertices += vertices; if (maxSubMeshVertices < vertices) maxSubMeshVertices = vertices; } if (!sharedGeometry && (splitSubMeshes || (totalVertices > 65535 && maxSubMeshVertices <= 65535))) { useOneBuffer_ = false; vertexBuffers_.Resize(numSubMeshes_); indexBuffers_.Resize(numSubMeshes_); } else { vertexBuffers_.Resize(1); indexBuffers_.Resize(1); } subMesh = subMeshes.GetChild("submesh"); unsigned indexStart = 0; unsigned vertexStart = 0; unsigned subMeshIndex = 0; PODVector<unsigned> vertexStarts; vertexStarts.Resize(numSubMeshes_); while (subMesh) { XMLElement geometry = subMesh.GetChild("geometry"); XMLElement faces = subMesh.GetChild("faces"); // If no submesh vertexbuffer, process the shared geometry, but do it only once unsigned vertices = 0; if (!geometry) { vertexStart = 0; if (!subMeshIndex) geometry = root.GetChild("sharedgeometry"); } if (geometry) vertices = geometry.GetInt("vertexcount"); ModelSubGeometryLodLevel subGeometryLodLevel; ModelVertexBuffer* vBuf; ModelIndexBuffer* iBuf; if (useOneBuffer_) { vBuf = &vertexBuffers_[0]; if (vertices) vBuf->vertices_.Resize(vertexStart + vertices); iBuf = &indexBuffers_[0]; subGeometryLodLevel.vertexBuffer_ = 0; subGeometryLodLevel.indexBuffer_ = 0; } else { vertexStart = 0; indexStart = 0; vBuf = &vertexBuffers_[subMeshIndex]; vBuf->vertices_.Resize(vertices); iBuf = &indexBuffers_[subMeshIndex]; subGeometryLodLevel.vertexBuffer_ = subMeshIndex; subGeometryLodLevel.indexBuffer_ = subMeshIndex; } // Store the start vertex for later use vertexStarts[subMeshIndex] = vertexStart; // Ogre may have multiple buffers in one submesh. These will be merged into one XMLElement bufferDef; if (geometry) bufferDef = geometry.GetChild("vertexbuffer"); while (bufferDef) { if (bufferDef.HasAttribute("positions")) vBuf->elementMask_ |= MASK_POSITION; if (bufferDef.HasAttribute("normals")) vBuf->elementMask_ |= MASK_NORMAL; if (bufferDef.HasAttribute("texture_coords")) { vBuf->elementMask_ |= MASK_TEXCOORD1; if (bufferDef.GetInt("texture_coords") > 1) vBuf->elementMask_ |= MASK_TEXCOORD2; } unsigned vertexNum = vertexStart; if (vertices) { XMLElement vertex = bufferDef.GetChild("vertex"); while (vertex) { XMLElement position = vertex.GetChild("position"); if (position) { // Convert from right- to left-handed float x = position.GetFloat("x"); float y = position.GetFloat("y"); float z = position.GetFloat("z"); Vector3 vec(x, y, -z); vBuf->vertices_[vertexNum].position_ = vec; boundingBox_.Merge(vec); } XMLElement normal = vertex.GetChild("normal"); if (normal) { // Convert from right- to left-handed float x = normal.GetFloat("x"); float y = normal.GetFloat("y"); float z = normal.GetFloat("z"); Vector3 vec(x, y, -z); vBuf->vertices_[vertexNum].normal_ = vec; } XMLElement uv = vertex.GetChild("texcoord"); if (uv) { float x = uv.GetFloat("u"); float y = uv.GetFloat("v"); Vector2 vec(x, y); vBuf->vertices_[vertexNum].texCoord1_ = vec; if (vBuf->elementMask_ & MASK_TEXCOORD2) { uv = uv.GetNext("texcoord"); if (uv) { float x = uv.GetFloat("u"); float y = uv.GetFloat("v"); Vector2 vec(x, y); vBuf->vertices_[vertexNum].texCoord2_ = vec; } } } vertexNum++; vertex = vertex.GetNext("vertex"); } } bufferDef = bufferDef.GetNext("vertexbuffer"); } unsigned triangles = faces.GetInt("count"); unsigned indices = triangles * 3; XMLElement triangle = faces.GetChild("face"); while (triangle) { unsigned v1 = triangle.GetInt("v1"); unsigned v2 = triangle.GetInt("v2"); unsigned v3 = triangle.GetInt("v3"); iBuf->indices_.Push(v3 + vertexStart); iBuf->indices_.Push(v2 + vertexStart); iBuf->indices_.Push(v1 + vertexStart); triangle = triangle.GetNext("face"); } subGeometryLodLevel.indexStart_ = indexStart; subGeometryLodLevel.indexCount_ = indices; if (vertexStart + vertices > 65535) iBuf->indexSize_ = sizeof(unsigned); XMLElement boneAssignments = subMesh.GetChild("boneassignments"); if (bones_.Size()) { if (boneAssignments) { XMLElement boneAssignment = boneAssignments.GetChild("vertexboneassignment"); while (boneAssignment) { unsigned vertex = boneAssignment.GetInt("vertexindex") + vertexStart; unsigned bone = boneAssignment.GetInt("boneindex"); float weight = boneAssignment.GetFloat("weight"); BoneWeightAssignment assign; assign.boneIndex_ = bone; assign.weight_ = weight; // Source data might have 0 weights. Disregard these if (assign.weight_ > 0.0f) { subGeometryLodLevel.boneWeights_[vertex].Push(assign); // Require skinning weight to be sufficiently large before vertex contributes to bone hitbox if (assign.weight_ > 0.33f) { // Check distance of vertex from bone to get bone max. radius information Vector3 bonePos = bones_[bone].derivedPosition_; Vector3 vertexPos = vBuf->vertices_[vertex].position_; float distance = (bonePos - vertexPos).Length(); if (distance > bones_[bone].radius_) { bones_[bone].collisionMask_ |= 1; bones_[bone].radius_ = distance; } // Build the hitbox for the bone bones_[bone].boundingBox_.Merge(bones_[bone].inverseWorldTransform_ * (vertexPos)); bones_[bone].collisionMask_ |= 2; } } boneAssignment = boneAssignment.GetNext("vertexboneassignment"); } } if ((subGeometryLodLevel.boneWeights_.Size()) && bones_.Size()) { vBuf->elementMask_ |= MASK_BLENDWEIGHTS | MASK_BLENDINDICES; bool sorted = false; // If amount of bones is larger than supported by HW skinning, must remap per submesh if (bones_.Size() > maxBones_) { HashMap<unsigned, unsigned> usedBoneMap; unsigned remapIndex = 0; for (HashMap<unsigned, PODVector<BoneWeightAssignment> >::Iterator i = subGeometryLodLevel.boneWeights_.Begin(); i != subGeometryLodLevel.boneWeights_.End(); ++i) { // Sort the bone assigns by weight Sort(i->second_.Begin(), i->second_.End(), CompareWeights); // Use only the first 4 weights for (unsigned j = 0; j < i->second_.Size() && j < 4; ++j) { unsigned originalIndex = i->second_[j].boneIndex_; if (!usedBoneMap.Contains(originalIndex)) { usedBoneMap[originalIndex] = remapIndex; remapIndex++; } i->second_[j].boneIndex_ = usedBoneMap[originalIndex]; } } // If still too many bones in one subgeometry, error if (usedBoneMap.Size() > maxBones_) ErrorExit("Too many bones (limit " + String(maxBones_) + ") in submesh " + String(subMeshIndex + 1)); // Write mapping of vertex buffer bone indices to original bone indices subGeometryLodLevel.boneMapping_.Resize(usedBoneMap.Size()); for (HashMap<unsigned, unsigned>::Iterator j = usedBoneMap.Begin(); j != usedBoneMap.End(); ++j) subGeometryLodLevel.boneMapping_[j->second_] = j->first_; sorted = true; } for (HashMap<unsigned, PODVector<BoneWeightAssignment> >::Iterator i = subGeometryLodLevel.boneWeights_.Begin(); i != subGeometryLodLevel.boneWeights_.End(); ++i) { // Sort the bone assigns by weight, if not sorted yet in bone remapping pass if (!sorted) Sort(i->second_.Begin(), i->second_.End(), CompareWeights); float totalWeight = 0.0f; float normalizationFactor = 0.0f; // Calculate normalization factor in case there are more than 4 blend weights, or they do not add up to 1 for (unsigned j = 0; j < i->second_.Size() && j < 4; ++j) totalWeight += i->second_[j].weight_; if (totalWeight > 0.0f) normalizationFactor = 1.0f / totalWeight; for (unsigned j = 0; j < i->second_.Size() && j < 4; ++j) { vBuf->vertices_[i->first_].blendIndices_[j] = i->second_[j].boneIndex_; vBuf->vertices_[i->first_].blendWeights_[j] = i->second_[j].weight_ * normalizationFactor; } // If there are less than 4 blend weights, fill rest with zero for (unsigned j = i->second_.Size(); j < 4; ++j) { vBuf->vertices_[i->first_].blendIndices_[j] = 0; vBuf->vertices_[i->first_].blendWeights_[j] = 0.0f; } vBuf->vertices_[i->first_].hasBlendWeights_ = true; } } } else if (boneAssignments) PrintLine("No skeleton loaded, skipping skinning information"); // Calculate center for the subgeometry Vector3 center = Vector3::ZERO; for (unsigned i = 0; i < iBuf->indices_.Size(); i += 3) { center += vBuf->vertices_[iBuf->indices_[i]].position_; center += vBuf->vertices_[iBuf->indices_[i + 1]].position_; center += vBuf->vertices_[iBuf->indices_[i + 2]].position_; } if (iBuf->indices_.Size()) center /= (float)iBuf->indices_.Size(); subGeometryCenters_.Push(center); indexStart += indices; vertexStart += vertices; OptimizeIndices(&subGeometryLodLevel, vBuf, iBuf); PrintLine("Processed submesh " + String(subMeshIndex + 1) + ": " + String(vertices) + " vertices " + String(triangles) + " triangles"); Vector<ModelSubGeometryLodLevel> thisSubGeometry; thisSubGeometry.Push(subGeometryLodLevel); subGeometries_.Push(thisSubGeometry); subMesh = subMesh.GetNext("submesh"); subMeshIndex++; } // Process LOD levels, if any XMLElement lods = root.GetChild("levelofdetail"); if (lods) { try { // For now, support only generated LODs, where the vertices are the same XMLElement lod = lods.GetChild("lodgenerated"); while (lod) { float distance = M_EPSILON; if (lod.HasAttribute("fromdepthsquared")) distance = sqrtf(lod.GetFloat("fromdepthsquared")); if (lod.HasAttribute("value")) distance = lod.GetFloat("value"); XMLElement lodSubMesh = lod.GetChild("lodfacelist"); while (lodSubMesh) { unsigned subMeshIndex = lodSubMesh.GetInt("submeshindex"); unsigned triangles = lodSubMesh.GetInt("numfaces"); ModelSubGeometryLodLevel newLodLevel; ModelSubGeometryLodLevel& originalLodLevel = subGeometries_[subMeshIndex][0]; // Copy all initial values newLodLevel = originalLodLevel; ModelVertexBuffer* vBuf; ModelIndexBuffer* iBuf; if (useOneBuffer_) { vBuf = &vertexBuffers_[0]; iBuf = &indexBuffers_[0]; } else { vBuf = &vertexBuffers_[subMeshIndex]; iBuf = &indexBuffers_[subMeshIndex]; } unsigned indexStart = iBuf->indices_.Size(); unsigned indexCount = triangles * 3; unsigned vertexStart = vertexStarts[subMeshIndex]; newLodLevel.distance_ = distance; newLodLevel.indexStart_ = indexStart; newLodLevel.indexCount_ = indexCount; // Append indices to the original index buffer XMLElement triangle = lodSubMesh.GetChild("face"); while (triangle) { unsigned v1 = triangle.GetInt("v1"); unsigned v2 = triangle.GetInt("v2"); unsigned v3 = triangle.GetInt("v3"); iBuf->indices_.Push(v3 + vertexStart); iBuf->indices_.Push(v2 + vertexStart); iBuf->indices_.Push(v1 + vertexStart); triangle = triangle.GetNext("face"); } OptimizeIndices(&newLodLevel, vBuf, iBuf); subGeometries_[subMeshIndex].Push(newLodLevel); PrintLine("Processed LOD level for submesh " + String(subMeshIndex + 1) + ": distance " + String(distance)); lodSubMesh = lodSubMesh.GetNext("lodfacelist"); } lod = lod.GetNext("lodgenerated"); } } catch (...) {} } // Process poses/morphs // First find out all pose definitions if (exportMorphs) { try { Vector<XMLElement> poses; XMLElement posesRoot = root.GetChild("poses"); if (posesRoot) { XMLElement pose = posesRoot.GetChild("pose"); while (pose) { poses.Push(pose); pose = pose.GetNext("pose"); } } // Then process animations using the poses XMLElement animsRoot = root.GetChild("animations"); if (animsRoot) { XMLElement anim = animsRoot.GetChild("animation"); while (anim) { String name = anim.GetAttribute("name"); float length = anim.GetFloat("length"); HashSet<unsigned> usedPoses; XMLElement tracks = anim.GetChild("tracks"); if (tracks) { XMLElement track = tracks.GetChild("track"); while (track) { XMLElement keyframes = track.GetChild("keyframes"); if (keyframes) { XMLElement keyframe = keyframes.GetChild("keyframe"); while (keyframe) { float time = keyframe.GetFloat("time"); XMLElement poseref = keyframe.GetChild("poseref"); // Get only the end pose if (poseref && time == length) usedPoses.Insert(poseref.GetInt("poseindex")); keyframe = keyframe.GetNext("keyframe"); } } track = track.GetNext("track"); } } if (usedPoses.Size()) { ModelMorph newMorph; newMorph.name_ = name; if (useOneBuffer_) newMorph.buffers_.Resize(1); else newMorph.buffers_.Resize(usedPoses.Size()); unsigned bufIndex = 0; for (HashSet<unsigned>::Iterator i = usedPoses.Begin(); i != usedPoses.End(); ++i) { XMLElement pose = poses[*i]; unsigned targetSubMesh = pose.GetInt("index"); XMLElement poseOffset = pose.GetChild("poseoffset"); if (useOneBuffer_) newMorph.buffers_[bufIndex].vertexBuffer_ = 0; else newMorph.buffers_[bufIndex].vertexBuffer_ = targetSubMesh; newMorph.buffers_[bufIndex].elementMask_ = MASK_POSITION; ModelVertexBuffer* vBuf = &vertexBuffers_[newMorph.buffers_[bufIndex].vertexBuffer_]; while (poseOffset) { // Convert from right- to left-handed unsigned vertexIndex = poseOffset.GetInt("index") + vertexStarts[targetSubMesh]; float x = poseOffset.GetFloat("x"); float y = poseOffset.GetFloat("y"); float z = poseOffset.GetFloat("z"); Vector3 vec(x, y, -z); if (vBuf->morphCount_ == 0) { vBuf->morphStart_ = vertexIndex; vBuf->morphCount_ = 1; } else { unsigned first = vBuf->morphStart_; unsigned last = first + vBuf->morphCount_ - 1; if (vertexIndex < first) first = vertexIndex; if (vertexIndex > last) last = vertexIndex; vBuf->morphStart_ = first; vBuf->morphCount_ = last - first + 1; } ModelVertex newVertex; newVertex.position_ = vec; newMorph.buffers_[bufIndex].vertices_.Push(MakePair(vertexIndex, newVertex)); poseOffset = poseOffset.GetNext("poseoffset"); } if (!useOneBuffer_) ++bufIndex; } morphs_.Push(newMorph); PrintLine("Processed morph " + name + " with " + String(usedPoses.Size()) + " sub-poses"); } anim = anim.GetNext("animation"); } } } catch (...) {} } // Check any of the buffers for vertices with missing blend weight assignments for (unsigned i = 0; i < vertexBuffers_.Size(); ++i) { if (vertexBuffers_[i].elementMask_ & MASK_BLENDWEIGHTS) { for (unsigned j = 0; j < vertexBuffers_[i].vertices_.Size(); ++j) if (!vertexBuffers_[i].vertices_[j].hasBlendWeights_) ErrorExit("Found a vertex with missing skinning information"); } } // Tangent generation if (generateTangents) { for (unsigned i = 0; i < subGeometries_.Size(); ++i) { for (unsigned j = 0; j < subGeometries_[i].Size(); ++j) { ModelVertexBuffer& vBuf = vertexBuffers_[subGeometries_[i][j].vertexBuffer_]; ModelIndexBuffer& iBuf = indexBuffers_[subGeometries_[i][j].indexBuffer_]; unsigned indexStart = subGeometries_[i][j].indexStart_; unsigned indexCount = subGeometries_[i][j].indexCount_; // If already has tangents, do not regenerate if (vBuf.elementMask_ & MASK_TANGENT || vBuf.vertices_.Empty() || iBuf.indices_.Empty()) continue; vBuf.elementMask_ |= MASK_TANGENT; if ((vBuf.elementMask_ & (MASK_POSITION | MASK_NORMAL | MASK_TEXCOORD1)) != (MASK_POSITION | MASK_NORMAL | MASK_TEXCOORD1)) ErrorExit("To generate tangents, positions normals and texcoords are required"); GenerateTangents(&vBuf.vertices_[0], sizeof(ModelVertex), &iBuf.indices_[0], sizeof(unsigned), indexStart, indexCount, offsetof(ModelVertex, normal_), offsetof(ModelVertex, texCoord1_), offsetof(ModelVertex, tangent_)); PrintLine("Generated tangents"); } } } }
void LoadSkeleton(const String& skeletonFileName) { // Process skeleton first (if found) XMLElement skeletonRoot; File skeletonFileSource(context_); skeletonFileSource.Open(skeletonFileName); if (!skelFile_->Load(skeletonFileSource)) PrintLine("Failed to load skeleton " + skeletonFileName); skeletonRoot = skelFile_->GetRoot(); if (skeletonRoot) { XMLElement bonesRoot = skeletonRoot.GetChild("bones"); XMLElement bone = bonesRoot.GetChild("bone"); while (bone) { unsigned index = bone.GetInt("id"); String name = bone.GetAttribute("name"); if (index >= bones_.Size()) bones_.Resize(index + 1); // Convert from right- to left-handed XMLElement position = bone.GetChild("position"); float x = position.GetFloat("x"); float y = position.GetFloat("y"); float z = position.GetFloat("z"); Vector3 pos(x, y, -z); XMLElement rotation = bone.GetChild("rotation"); XMLElement axis = rotation.GetChild("axis"); float angle = -rotation.GetFloat("angle") * M_RADTODEG; x = axis.GetFloat("x"); y = axis.GetFloat("y"); z = axis.GetFloat("z"); Vector3 axisVec(x, y, -z); Quaternion rot(angle, axisVec); bones_[index].name_ = name; bones_[index].parentIndex_ = index; // Fill in the correct parent later bones_[index].bindPosition_ = pos; bones_[index].bindRotation_ = rot; bones_[index].bindScale_ = Vector3::ONE; bones_[index].collisionMask_ = 0; bones_[index].radius_ = 0.0f; bone = bone.GetNext("bone"); } // Go through the bone hierarchy XMLElement boneHierarchy = skeletonRoot.GetChild("bonehierarchy"); XMLElement boneParent = boneHierarchy.GetChild("boneparent"); while (boneParent) { String bone = boneParent.GetAttribute("bone"); String parent = boneParent.GetAttribute("parent"); unsigned i = 0, j = 0; for (i = 0; i < bones_.Size() && bones_[i].name_ != bone; ++i); for (j = 0; j < bones_.Size() && bones_[j].name_ != parent; ++j); if (i >= bones_.Size() || j >= bones_.Size()) ErrorExit("Found indeterminate parent bone assignment"); bones_[i].parentIndex_ = j; boneParent = boneParent.GetNext("boneparent"); } // Calculate bone derived positions for (unsigned i = 0; i < bones_.Size(); ++i) { Vector3 derivedPosition = bones_[i].bindPosition_; Quaternion derivedRotation = bones_[i].bindRotation_; Vector3 derivedScale = bones_[i].bindScale_; unsigned index = bones_[i].parentIndex_; if (index != i) { for (;;) { derivedPosition = bones_[index].bindPosition_ + (bones_[index].bindRotation_ * (bones_[index].bindScale_ * derivedPosition)); derivedRotation = bones_[index].bindRotation_ * derivedRotation; derivedScale = bones_[index].bindScale_ * derivedScale; if (bones_[index].parentIndex_ != index) index = bones_[index].parentIndex_; else break; } } bones_[i].derivedPosition_ = derivedPosition; bones_[i].derivedRotation_ = derivedRotation; bones_[i].derivedScale_ = derivedScale; bones_[i].worldTransform_ = Matrix3x4(derivedPosition, derivedRotation, derivedScale); bones_[i].inverseWorldTransform_ = bones_[i].worldTransform_.Inverse(); } PrintLine("Processed skeleton"); } }
int main(int argc, char *argv[]) { char **av ; int ac, nargs ; MRI *mri=NULL ; char *xform_fname=NULL, *in_fname=NULL, *out_fname=NULL ; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mri_add_xform_to_header.c,v 1.12 2011/03/02 00:04:13 nicks Exp $", "$Name: stable5 $"); argc -= nargs; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; if (argc == 1) { usage_exit(); } ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc < 2) { ErrorExit(ERROR_BADPARM, "%s: no transform name specified", Progname) ; } xform_fname = argv[1] ; if (argc < 3) { ErrorExit(ERROR_BADPARM, "%s: no input name specified", Progname) ; } in_fname = argv[2] ; if (argc < 4) { out_fname = in_fname ; } else { out_fname = argv[3] ; } if (verbose) { fprintf(stderr, "reading from %s...", in_fname) ; } // we have two cases, in_fname is just a directory name or .mgz if (fio_IsDirectory(in_fname)) { mri = MRIreadInfo(in_fname) ; // must be old COR volume } else if (fio_FileExistsReadable(in_fname)) { char *ext = fio_extension(in_fname); if (ext==0) { ErrorExit(ERROR_BADPARM, "%s: no extension found", Progname) ; } printf("INFO: extension is %s\n", ext); if (strcmp(ext, "mgz")==0 || strcmp(ext, "mgh")==0) { mri = MRIread(in_fname); // mgh or mgz } else { ErrorExit(ERROR_BADPARM, "%s: currently only .mgz or .mgh saves transform name", Progname) ; } } if (!mri) ErrorExit(ERROR_NO_FILE, "%s: could not open source file %s", Progname, in_fname) ; if (! CopyNameOnly) { // why do we need to load the transform at this time // mri is removed anyway???? -- good point, added -s for noload if (input_transform_file(xform_fname, &mri->transform) != OK) ErrorPrintf(ERROR_NO_MEMORY, "%s: could not read xform file '%s'\n", Progname, xform_fname); // my guess is just to verify the validity of the transform? mri->linear_transform = get_linear_transform_ptr(&mri->transform) ; mri->inverse_linear_transform = get_inverse_linear_transform_ptr(&mri->transform) ; mri->free_transform = 1 ; } strcpy(mri->transform_fname, xform_fname) ; if (verbose) { fprintf(stderr, "done.\nwriting to %s...", out_fname) ; } // this writes COR-.info only if (fio_IsDirectory(out_fname)) { MRIwriteInfo(mri, out_fname) ; } else { MRIwrite(mri, out_fname); // currently only mgh format write xform info } if (verbose) { fprintf(stderr, "done.\n") ; } MRIfree(&mri) ; exit(0) ; return(0) ; }
int main(int argc, char *argv[]) { char **av, *ltafn1, *ltafn2, *ltafn_total; LTA *lta1, *lta2, *lta_total; FILE *fo; MATRIX *r_to_i_1, *i_to_r_1, *i_to_r_2, *r_to_i_2; MATRIX *RAS_1_to_1, *RAS_2_to_2, *m_tmp; int nargs, ac; int type = 0; Progname = argv[0]; nargs = handle_version_option (argc, argv, "$Id: mri_concatenate_lta.c,v 1.10 2011/03/16 21:23:48 nicks Exp $", "$Name: $"); if (nargs && argc - nargs == 1) { exit (0); } argc -= nargs ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc != 4) { usage(1); } ltafn1 = argv[1]; ltafn2 = argv[2]; ltafn_total = argv[3]; printf("Read individual LTAs\n"); //lta1 = ltaReadFileEx(ltafn1); TRANSFORM * trans = TransformRead(ltafn1); lta1 = (LTA *)trans->xform ; if (!lta1) { ErrorExit(ERROR_BADFILE, "%s: can't read file %s",Progname, ltafn1); } if (invert1) { VOL_GEOM vgtmp; LT *lt; MATRIX *m_tmp = lta1->xforms[0].m_L ; lta1->xforms[0].m_L = MatrixInverse(lta1->xforms[0].m_L, NULL) ; MatrixFree(&m_tmp) ; lt = <a1->xforms[0]; if (lt->dst.valid == 0 || lt->src.valid == 0) { fprintf (stderr, "WARNING:********************************************************\n"); fprintf (stderr, "WARNING:dst or src volume is invalid. Inverse likely wrong.\n"); fprintf (stderr, "WARNING:********************************************************\n"); } copyVolGeom(<->dst, &vgtmp); copyVolGeom(<->src, <->dst); copyVolGeom(&vgtmp, <->src); } if (strcmp(ltafn2,"identity.nofile") == 0) { type = TransformFileNameType(ltafn_total); if (type == MNI_TRANSFORM_TYPE) { ltaMNIwrite(lta1, ltafn_total); } else { //change type to VOXEL_VOXEL if (lta1->type != out_type) { LTAchangeType(lta1, out_type); } printf("Writing LTA to file %s...\n", ltafn_total); fo = fopen(ltafn_total,"w"); if (fo==NULL) ErrorExit(ERROR_BADFILE, "%s: can't create file %s",Progname, ltafn_total); LTAprint(fo, lta1); fclose(fo); } LTAfree(<a1); printf("%s successful.\n", Progname); return 0; } type = TransformFileNameType(ltafn2); if (type == MNI_TRANSFORM_TYPE) { if (invert2 != 0) ErrorExit (ERROR_BADFILE, "%s: LTA2 is talairach.xfm, and shouldn't be inverted ", Progname); lta2 = ltaMNIreadEx(ltafn2) ; //the talairach xform is supposed to be linear_RAS_TO_RAS, right? Yes lta2->type = LINEAR_RAS_TO_RAS; if (tal_src_file == 0 && lta2->xforms[0].src.valid == 0) ErrorExit (ERROR_BADFILE, "%s: pls use -tal option to give talairach src and " "template filenames",Progname); if (tal_dst_file == 0 && lta2->xforms[0].dst.valid == 0) ErrorExit (ERROR_BADFILE, "%s: pls use -tal option to give talairach src and " "template filenames",Progname); if (tal_src_file != 0) { LTAmodifySrcDstGeom(lta2, tal_src, NULL); // add src and dst information } if (tal_dst_file != 0) { LTAmodifySrcDstGeom(lta2, NULL, tal_dst); // add src and dst information } } else { TRANSFORM * trans = TransformRead(ltafn2); lta2 = (LTA *)trans->xform ; //lta2 = ltaReadFileEx(ltafn2); } if (!lta2) { ErrorExit(ERROR_BADFILE, "%s: can't read file %s",Progname, ltafn2); } if (invert2) { VOL_GEOM vgtmp; LT *lt; MATRIX *m_tmp = lta2->xforms[0].m_L ; lta2->xforms[0].m_L = MatrixInverse(lta2->xforms[0].m_L, NULL) ; MatrixFree(&m_tmp) ; lt = <a2->xforms[0]; if (lt->dst.valid == 0 || lt->src.valid == 0) { fprintf (stderr, "WARNING:********************************************************\n"); fprintf (stderr, "WARNING:dst or src volume is invalid. Inverse likely wrong.\n"); fprintf (stderr, "WARNING:********************************************************\n"); } copyVolGeom(<->dst, &vgtmp); copyVolGeom(<->src, <->dst); copyVolGeom(&vgtmp, <->src); } if (vg_isEqual(<a1->xforms[0].dst, <a2->xforms[0].src) == 0) { /* ErrorExit(ERROR_BADFILE, "%s: dst volume of lta1 doesn't match src volume of lta2",Progname);*/ printf("Warning: dst volume of lta1 doesn't match src volume of lta2\n"); printf("Volume geometry for lta1-dst: \n"); vg_print(<a1->xforms[0].dst); printf("Volume geometry for lta2-src:\n"); vg_print(<a2->xforms[0].src); } printf("Combining the two LTAs to get a RAS-to-RAS from src " "of LTA1 to dst of LTA2...\n"); if (lta1->type == LINEAR_RAS_TO_RAS) { RAS_1_to_1 = MatrixCopy(lta1->xforms[0].m_L, NULL); } else if (lta1->type == LINEAR_VOX_TO_VOX) { r_to_i_1 = vg_r_to_i(<a1->xforms[0].src); i_to_r_1 = vg_i_to_r(<a1->xforms[0].dst); if (!r_to_i_1 || !i_to_r_1) ErrorExit(ERROR_BADFILE, "%s: failed to convert LTA1 to RAS_to_RAS",Progname); m_tmp = MatrixMultiply(lta1->xforms[0].m_L, r_to_i_1, NULL); RAS_1_to_1 = MatrixMultiply(i_to_r_1, m_tmp, NULL); MatrixFree(&m_tmp); } else { ErrorExit(ERROR_BADFILE, "%s: unknown transform type for LTA1",Progname); } if (lta2->type == LINEAR_RAS_TO_RAS) { RAS_2_to_2 = MatrixCopy(lta2->xforms[0].m_L, NULL); } else if (lta2->type == LINEAR_VOX_TO_VOX) { r_to_i_2 = vg_r_to_i(<a2->xforms[0].src); i_to_r_2 = vg_i_to_r(<a2->xforms[0].dst); if (!r_to_i_2 || !i_to_r_2) ErrorExit(ERROR_BADFILE, "%s: failed to convert LTA1 to RAS_to_RAS",Progname); m_tmp = MatrixMultiply(lta2->xforms[0].m_L, r_to_i_2, NULL); RAS_2_to_2 = MatrixMultiply(i_to_r_2, m_tmp, NULL); MatrixFree(&m_tmp); } else { ErrorExit(ERROR_BADFILE, "%s: unknown transform type for LTA1",Progname); } lta_total = LTAalloc(1, NULL); lta_total->type = LINEAR_RAS_TO_RAS; MatrixMultiply(RAS_2_to_2, RAS_1_to_1, lta_total->xforms[0].m_L); lta_total->xforms[0].src = lta1->xforms[0].src; lta_total->xforms[0].dst = lta2->xforms[0].dst; lta_total->xforms[0].x0 = 0; lta_total->xforms[0].y0 = 0; lta_total->xforms[0].z0 = 0; lta_total->xforms[0].sigma = 1.0f; type = TransformFileNameType(ltafn_total); if (type == MNI_TRANSFORM_TYPE) { ltaMNIwrite(lta_total, ltafn_total); } else { //change type to VOXEL_VOXEL if (lta_total->type != out_type) { LTAchangeType(lta_total, out_type); } printf("Writing combined LTA to file %s...\n", ltafn_total); fo = fopen(ltafn_total,"w"); if (fo==NULL) ErrorExit(ERROR_BADFILE, "%s: can't create file %s",Progname, ltafn_total); LTAprint(fo, lta_total); fclose(fo); } LTAfree(<a1); LTAfree(<a2); LTAfree(<a_total); MatrixFree(&RAS_1_to_1); MatrixFree(&RAS_2_to_2); if (tal_src) { MRIfree(&tal_src); } if (tal_dst) { MRIfree(&tal_dst); } printf("%s successful.\n", Progname); return(0); } /* end main() */
int main(int argc, char *argv[]) { char **av ; int ac, nargs ; MRI *mri_in_labeled, *mri_T1, *mri_out_labeled = NULL ; char *in_fname, *T1_fname, *out_fname ; int msec, minutes, seconds ; struct timeb start ; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mri_edit_segmentation.c,v 1.11 2011/03/02 00:04:15 nicks Exp $", "$Name: stable5 $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc < 4) usage_exit() ; in_fname = argv[1] ; T1_fname = argv[2] ; out_fname = argv[3] ; printf("reading from %s...\n", in_fname) ; mri_in_labeled = MRIread(in_fname) ; if (!mri_in_labeled) ErrorExit(ERROR_NO_FILE, "%s: could not open labeled file %s", Progname, in_fname) ; mri_T1 = MRIread(T1_fname) ; if (!mri_T1) ErrorExit(ERROR_NO_FILE, "%s: could not open T1 file %s", Progname, in_fname) ; TimerStart(&start) ; if (unknown_only == 0 && border_only == 0) { mri_out_labeled = edit_hippocampus(mri_in_labeled, mri_T1, NULL); edit_amygdala(mri_out_labeled, mri_T1, mri_out_labeled); edit_caudate(mri_out_labeled, mri_T1, mri_out_labeled); edit_lateral_ventricles(mri_out_labeled, mri_T1, mri_out_labeled); /* must be after hippo */ edit_cortical_gray_matter(mri_out_labeled, mri_T1, mri_out_labeled); } else mri_out_labeled = MRIcopy(mri_in_labeled, NULL) ; if (border_only == 0 || unknown_only != 0) edit_ventricular_unknowns(mri_out_labeled, mri_T1, mri_out_labeled) ; if (border_only != 0 || unknown_only == 0) edit_border_voxels(mri_out_labeled, mri_T1, mri_out_labeled) ; printf("writing output volume to %s...\n", out_fname) ; MRIwrite(mri_out_labeled, out_fname) ; msec = TimerStop(&start) ; seconds = nint((float)msec/1000.0f) ; minutes = seconds / 60 ; seconds = seconds % 60 ; printf("segmentation adjustment took %d minutes and %d seconds.\n", minutes, seconds) ; exit(0) ; return(0) ; }
int main(int argc, char *argv[]) { char **av ; int ac, nargs ; char *training_file_name, source_fname[100], target_fname[100], *cp, line[250], *output_file_name ; FILE *fp ; int fno, nfiles ; MRI *mri_src, *mri_target, *mri_wm, *mri_priors = NULL ; /* rkt: check for and handle version tag */ nargs = handle_version_option (argc, argv, "$Id: mri_build_priors.c,v 1.8 2011/03/02 00:04:13 nicks Exp $", "$Name: $"); if (nargs && argc - nargs == 1) exit (0); argc -= nargs; Progname = argv[0] ; ErrorInit(NULL, NULL, NULL) ; DiagInit(NULL, NULL, NULL) ; ac = argc ; av = argv ; for ( ; argc > 1 && ISOPTION(*argv[1]) ; argc--, argv++) { nargs = get_option(argc, argv) ; argc -= nargs ; argv += nargs ; } if (argc < 2) training_file_name = "train.dat" ; else training_file_name = argv[1] ; if (argc < 3) output_file_name = "priors.mnc" ; else output_file_name = argv[2] ; fp = fopen(training_file_name, "r") ; if (!fp) ErrorExit(ERROR_NO_FILE, "%s: could not open file %s", Progname, training_file_name) ; nfiles = 0 ; while ((cp = fgetl(line, 299, fp)) != NULL) nfiles++ ; fprintf(stderr, "processing %d files\n", nfiles) ; rewind(fp) ; fno = 0 ; while ((cp = fgetl(line, 299, fp)) != NULL) { sscanf(cp, "%s %s", source_fname, target_fname) ; fprintf(stderr, "file[%d]: %s --> %s\n", fno, source_fname, target_fname); mri_src = MRIread(source_fname) ; if (!mri_src) { fprintf(stderr, "could not read MR image %s\n", source_fname) ; continue ; } mri_wm = MRIread(target_fname) ; if (!mri_wm) { fprintf(stderr, "could not read MR image %s\n", target_fname) ; MRIfree(&mri_src) ; continue ; } mri_target = MRICbuildTargetImage(mri_src, NULL, mri_wm, 0, 0) ; MRIfree(&mri_src) ; MRIfree(&mri_wm) ; fno++ ; mri_priors = MRICupdatePriors(mri_target, mri_priors, PRIOR_SCALE) ; MRIfree(&mri_target) ; } #if 0 if (fno > 0) MRIscalarMul(mri_priors, mri_priors, 1.0f / (float)fno) ; #else MRInormalizePriors(mri_priors) ; #endif MRIwrite(mri_priors, output_file_name) ; fclose(fp) ; exit(0) ; return(0) ; }
/** main **/ int main(int argc, char **argv) { char *user_msg; int c = 0, cmdlist = 0; char *cmdexport = NULL; char *cmdimport = NULL; #ifndef WIN32 char *dir = DEFAULTDIR; char *group = GROUPGLOBAL; int gid; #endif /* Setting the name */ OS_SetName(ARGV0); while((c = getopt(argc, argv, "Vhle:i:")) != -1){ switch(c){ case 'V': print_version(); break; case 'h': helpmsg(); break; case 'd': nowDebug(); break; case 'e': #ifdef CLIENT ErrorExit("%s: You can't export keys on an agent", ARGV0); #endif if(!optarg) ErrorExit("%s: -e needs an argument",ARGV0); cmdexport = optarg; break; case 'i': #ifndef CLIENT ErrorExit("%s: You can't import keys on the manager.", ARGV0); #endif if(!optarg) ErrorExit("%s: -i needs an argument",ARGV0); cmdimport = optarg; break; case 'l': cmdlist = 1; break; default: helpmsg(); break; } } /* Getting currently time */ time1 = time(0); restart_necessary = 0; #ifndef WIN32 /* Getting the group name */ gid = Privsep_GetGroup(group); if(gid < 0) { ErrorExit(USER_ERROR, ARGV0, "", group); } /* Setting the group */ if(Privsep_SetGroup(gid) < 0) { ErrorExit(SETGID_ERROR, ARGV0, group); } /* Chrooting to the default directory */ if(Privsep_Chroot(dir) < 0) { ErrorExit(CHROOT_ERROR, ARGV0, dir); } /* Inside chroot now */ nowChroot(); /* Starting signal handler */ StartSIG2(ARGV0, manage_shutdown); #endif if(cmdlist == 1) { list_agents(cmdlist); exit(0); } else if(cmdimport) { k_import(cmdimport); exit(0); } else if(cmdexport) { k_extract(cmdexport); exit(0); } /* Little shell */ while(1) { int leave_s = 0; print_banner(); /* Get ACTION from the environment. If ACTION is specified, * we must set leave_s = 1 to ensure that the loop will end */ user_msg = getenv("OSSEC_ACTION"); if (user_msg == NULL) { user_msg = read_from_user(); } else{ leave_s = 1; } /* All the allowed actions */ switch(user_msg[0]) { case 'A': case 'a': add_agent(); break; case 'e': case 'E': k_extract(NULL); break; case 'i': case 'I': k_import(NULL); break; case 'l': case 'L': list_agents(0); break; case 'r': case 'R': remove_agent(); break; case 'q': case 'Q': leave_s = 1; break; case 'V': print_version(); break; default: printf("\n ** Invalid Action ** \n\n"); break; } if(leave_s) { break; } continue; } /* Checking if restart message is necessary */ if(restart_necessary) { printf(MUST_RESTART); } else { printf("\n"); } printf(EXIT); return(0); }
/** main **/ int main(int argc, char **argv) { char *dir = DEFAULTDIR; char *group = GROUPGLOBAL; char *user = USER; char *agent_id = NULL; int gid = 0; int uid = 0; int c = 0, info_agent = 0, update_rootcheck = 0, list_agents = 0, show_last = 0, resolved_only = 0; int active_only = 0, csv_output = 0; char shost[512]; /* Setting the name */ OS_SetName(ARGV0); /* user arguments */ if(argc < 2) { helpmsg(); } while((c = getopt(argc, argv, "VhqrDdLlcsu:i:")) != -1) { switch(c){ case 'V': print_version(); break; case 'h': helpmsg(); break; case 'D': nowDebug(); break; case 'l': list_agents++; break; case 's': csv_output = 1; break; case 'c': active_only++; break; case 'r': resolved_only = 1; break; case 'q': resolved_only = 2; break; case 'L': show_last = 1; break; case 'i': info_agent++; if(!optarg) { merror("%s: -u needs an argument",ARGV0); helpmsg(); } agent_id = optarg; break; case 'u': if(!optarg) { merror("%s: -u needs an argument",ARGV0); helpmsg(); } agent_id = optarg; update_rootcheck = 1; break; default: helpmsg(); break; } } /* Getting the group name */ gid = Privsep_GetGroup(group); uid = Privsep_GetUser(user); if(gid < 0) { ErrorExit(USER_ERROR, ARGV0, user, group); } /* Setting the group */ if(Privsep_SetGroup(gid) < 0) { ErrorExit(SETGID_ERROR,ARGV0, group); } /* Chrooting to the default directory */ if(Privsep_Chroot(dir) < 0) { ErrorExit(CHROOT_ERROR, ARGV0, dir); } /* Inside chroot now */ nowChroot(); /* Setting the user */ if(Privsep_SetUser(uid) < 0) { ErrorExit(SETUID_ERROR, ARGV0, user); } /* Getting servers hostname */ memset(shost, '\0', 512); if(gethostname(shost, 512 -1) != 0) { strncpy(shost, "localhost", 32); return(0); } /* Listing available agents. */ if(list_agents) { if(!csv_output) { printf("\nOSPatrol %s. List of available agents:", ARGV0); printf("\n ID: 000, Name: %s (server), IP: 127.0.0.1, " "Active/Local\n", shost); } else { printf("000,%s (server),127.0.0.1,Active/Local,\n", shost); } print_agents(1, active_only, csv_output); printf("\n"); exit(0); } /* Update rootcheck database. */ if(update_rootcheck) { /* Cleaning all agents (and server) db. */ if(strcmp(agent_id, "all") == 0) { DIR *sys_dir; struct dirent *entry; sys_dir = opendir(ROOTCHECK_DIR); if(!sys_dir) { ErrorExit("%s: Unable to open: '%s'", ARGV0, ROOTCHECK_DIR); } while((entry = readdir(sys_dir)) != NULL) { FILE *fp; char full_path[OS_MAXSTR +1]; /* Do not even attempt to delete . and .. :) */ if((strcmp(entry->d_name,".") == 0)|| (strcmp(entry->d_name,"..") == 0)) { continue; } snprintf(full_path, OS_MAXSTR,"%s/%s", ROOTCHECK_DIR, entry->d_name); fp = fopen(full_path, "w"); if(fp) { fclose(fp); } if(entry->d_name[0] == '.') { unlink(full_path); } } closedir(sys_dir); printf("\n** Policy and auditing database updated.\n\n"); exit(0); } else if((strcmp(agent_id, "000") == 0) || (strcmp(agent_id, "local") == 0)) { char final_dir[1024]; FILE *fp; snprintf(final_dir, 1020, "/%s/rootcheck", ROOTCHECK_DIR); fp = fopen(final_dir, "w"); if(fp) { fclose(fp); } unlink(final_dir); printf("\n** Policy and auditing database updated.\n\n"); exit(0); } /* Database from remote agents. */ else { int i; keystore keys; OS_ReadKeys(&keys); i = OS_IsAllowedID(&keys, agent_id); if(i < 0) { printf("\n** Invalid agent id '%s'.\n", agent_id); helpmsg(); } /* Deleting syscheck */ delete_rootcheck(keys.keyentries[i]->name, keys.keyentries[i]->ip->ip, 0); printf("\n** Policy and auditing database updated.\n\n"); exit(0); } } /* Printing information from an agent. */ if(info_agent) { int i; char final_ip[128 +1]; char final_mask[128 +1]; keystore keys; if((strcmp(agent_id, "000") == 0) || (strcmp(agent_id, "local") == 0)) { if(!csv_output) printf("\nPolicy and auditing events for local system '%s - %s':\n", shost, "127.0.0.1"); print_rootcheck(NULL, NULL, NULL, resolved_only, csv_output, show_last); } else { OS_ReadKeys(&keys); i = OS_IsAllowedID(&keys, agent_id); if(i < 0) { printf("\n** Invalid agent id '%s'.\n", agent_id); helpmsg(); } /* Getting netmask from ip. */ final_ip[128] = '\0'; final_mask[128] = '\0'; getNetmask(keys.keyentries[i]->ip->netmask, final_mask, 128); snprintf(final_ip, 128, "%s%s",keys.keyentries[i]->ip->ip, final_mask); if(!csv_output) printf("\nPolicy and auditing events for agent " "'%s (%s) - %s':\n", keys.keyentries[i]->name, keys.keyentries[i]->id, final_ip); print_rootcheck(keys.keyentries[i]->name, keys.keyentries[i]->ip->ip, NULL, resolved_only, csv_output, show_last); } exit(0); } printf("\n** Invalid argument combination.\n"); helpmsg(); return(0); }
/** void HandleRemote(int position, int uid) v0.2 2005/11/09 * Handle remote connections * v0.2, 2005/11/09 * v0.1, 2004/7/30 */ void HandleRemote(int position, int uid) { /* If syslog connection and allowips is not defined, exit */ if(logr.conn[position] == SYSLOG_CONN) { if(logr.allowips == NULL) { ErrorExit(NO_SYSLOG, ARGV0); } else { os_ip **tmp_ips; tmp_ips = logr.allowips; while(*tmp_ips) { verbose("%s: Remote syslog allowed from: '%s'", ARGV0, (*tmp_ips)->ip); tmp_ips++; } } } /* Bind TCP */ if(logr.proto[position] == IPPROTO_TCP) { if((logr.sock = OS_Bindporttcp(logr.port[position], logr.lip[position])) < 0) { ErrorExit(BIND_ERROR, ARGV0, logr.port[position]); } } else { /* Using UDP. Fast, unreliable.. perfect */ if((logr.sock = OS_Bindportudp(logr.port[position], logr.lip[position])) < 0) { ErrorExit(BIND_ERROR, ARGV0, logr.port[position]); } } /* Revoking the privileges */ if(Privsep_SetUser(uid) < 0) { ErrorExit(SETUID_ERROR,ARGV0, REMUSER); } /* Creating PID */ if(CreatePID(ARGV0, getpid()) < 0) { ErrorExit(PID_ERROR,ARGV0); } /* Start up message */ verbose(STARTUP_MSG, ARGV0, (int)getpid()); /* If Secure connection, deal with it */ if(logr.conn[position] == SECURE_CONN) { HandleSecure(); } else if(logr.proto[position] == IPPROTO_TCP) { HandleSyslogTCP(); } /* If not, deal with syslog */ else { HandleSyslog(); } return; }
/** int main(int argc, char **argv) */ int main(int argc, char **argv) { int t_config = 0; int c = 0, m_queue = 0; char *ut_str = NULL; char *dir = DEFAULTDIR; // TODO: delete or implement char *user __attribute__((unused)) = USER; // TODO: delete or implement char *group __attribute__((unused)) = GROUPGLOBAL; char *cfg = DEFAULTCPATH; /* Setting the name */ OS_SetName(ARGV0); thishour = 0; today = 0; prev_year = 0; full_output = 0; alert_only = 0; active_responses = NULL; memset(prev_month, '\0', 4); while((c = getopt(argc, argv, "VatvdhU:u:g:D:c:")) != -1){ switch(c){ case 'V': print_version(); break; case 't': t_config = 1; break; case 'h': logtest_help(ARGV0); break; case 'd': nowDebug(); break; case 'U': if(!optarg) ErrorExit("%s: -U needs an argument",ARGV0); ut_str = optarg; break; case 'u': if(!optarg) ErrorExit("%s: -u needs an argument",ARGV0); user = optarg; break; case 'g': if(!optarg) ErrorExit("%s: -g needs an argument",ARGV0); group = optarg; break; case 'D': if(!optarg) ErrorExit("%s: -D needs an argument",ARGV0); dir = optarg; break; case 'c': if(!optarg) ErrorExit("%s: -c needs an argument",ARGV0); cfg = optarg; break; case 'a': alert_only = 1; break; case 'v': full_output = 1; break; default: logtest_help(ARGV0); break; } } /* Reading configuration file */ if(GlobalConf(cfg) < 0) { ErrorExit(CONFIG_ERROR,ARGV0, cfg); } debug1(READ_CONFIG, ARGV0); /* Getting servers hostname */ memset(__shost, '\0', 512); if(gethostname(__shost, 512 -1) != 0) { strncpy(__shost, OSSEC_SERVER, 512 -1); } else { char *_ltmp; /* Remove domain part if available */ _ltmp = strchr(__shost, '.'); if(_ltmp) *_ltmp = '\0'; } if(chdir(dir) != 0) ErrorExit(CHROOT_ERROR,ARGV0,dir); /* * Anonymous Section: Load rules, decoders, and lists * * As lists require two pass loading of rules that make use of list lookups * are created with blank database structs, and need to be filled in after * completion of all rules and lists. */ { { /* Lad decders */ /* Initializing the decoders list */ OS_CreateOSDecoderList(); if(!Config.decoders) { /* Legacy loading */ /* Reading decoders */ if(!ReadDecodeXML("etc/decoder.xml")) { ErrorExit(CONFIG_ERROR, ARGV0, XML_DECODER); } /* Reading local ones. */ c = ReadDecodeXML("etc/local_decoder.xml"); if(!c) { if((c != -2)) ErrorExit(CONFIG_ERROR, ARGV0, XML_LDECODER); } else { verbose("%s: INFO: Reading local decoder file.", ARGV0); } } else { /* New loaded based on file speified in ossec.conf */ char **decodersfiles; decodersfiles = Config.decoders; while( decodersfiles && *decodersfiles) { verbose("%s: INFO: Reading decoder file %s.", ARGV0, *decodersfiles); if(!ReadDecodeXML(*decodersfiles)) ErrorExit(CONFIG_ERROR, ARGV0, *decodersfiles); free(*decodersfiles); decodersfiles++; } } /* Load decoders */ SetDecodeXML(); } { /* Load Lists */ /* Initializing the lists of list struct */ Lists_OP_CreateLists(); /* Load each list into list struct */ { char **listfiles; listfiles = Config.lists; while(listfiles && *listfiles) { verbose("%s: INFO: Reading the lists file: '%s'", ARGV0, *listfiles); if(Lists_OP_LoadList(*listfiles) < 0) ErrorExit(LISTS_ERROR, ARGV0, *listfiles); free(*listfiles); listfiles++; } free(Config.lists); Config.lists = NULL; } } { /* Load Rules */ /* Creating the rules list */ Rules_OP_CreateRules(); /* Reading the rules */ { char **rulesfiles; rulesfiles = Config.includes; while(rulesfiles && *rulesfiles) { debug1("%s: INFO: Reading rules file: '%s'", ARGV0, *rulesfiles); if(Rules_OP_ReadRules(*rulesfiles) < 0) ErrorExit(RULES_ERROR, ARGV0, *rulesfiles); free(*rulesfiles); rulesfiles++; } free(Config.includes); Config.includes = NULL; } /* Find all rules with that require list lookups and attache the * the correct list struct to the rule. This keeps rules from having to * search thought the list of lists for the correct file during rule evaluation. */ OS_ListLoadRules(); } } /* Fixing the levels/accuracy */ { int total_rules; RuleNode *tmp_node = OS_GetFirstRule(); total_rules = _setlevels(tmp_node, 0); debug1("%s: INFO: Total rules enabled: '%d'", ARGV0, total_rules); } /* Creating a rules hash (for reading alerts from other servers). */ { RuleNode *tmp_node = OS_GetFirstRule(); Config.g_rules_hash = OSHash_Create(); if(!Config.g_rules_hash) { ErrorExit(MEM_ERROR, ARGV0); } AddHash_Rule(tmp_node); } if(t_config == 1) { exit(0); } /* Start up message */ verbose(STARTUP_MSG, ARGV0, getpid()); /* Going to main loop */ OS_ReadMSG(m_queue, ut_str); exit(0); }
float partQ__align( char **seq1, char **seq2, double *eff1, double *eff2, int icyc, int jcyc, int alloclen, LocalHom ***localhom, float *impmatch, int start1, int end1, int start2, int end2, int *gapmap1, int *gapmap2, char *sgap1, char *sgap2, char *egap1, char *egap2 ) /* score no keisan no sai motokaraaru gap no atukai ni mondai ga aru */ { // int k; register int i, j; int lasti, lastj; /* outgap == 0 -> lgth1, outgap == 1 -> lgth1+1 */ int lgth1, lgth2; int resultlen; float wm = 0.0; /* int ?????? */ float g; float *currentw, *previousw; #if 1 float *wtmp; int *ijppt; float *mjpt, *prept, *curpt; int *mpjpt; #endif static float mi, *m; static int **ijp; static int mpi, *mp; static float *w1, *w2; static float *match; static float *initverticalw; /* kufuu sureba iranai */ static float *lastverticalw; /* kufuu sureba iranai */ static char **mseq1; static char **mseq2; static char **mseq; static float *digf1; static float *digf2; static float *diaf1; static float *diaf2; static float *gapz1; static float *gapz2; static float *gapf1; static float *gapf2; static float *ogcp1g; static float *ogcp2g; static float *fgcp1g; static float *fgcp2g; static float *og_h_dg_n1_p; static float *og_h_dg_n2_p; static float *fg_h_dg_n1_p; static float *fg_h_dg_n2_p; static float *og_t_fg_h_dg_n1_p; static float *og_t_fg_h_dg_n2_p; static float *fg_t_og_h_dg_n1_p; static float *fg_t_og_h_dg_n2_p; static float *gapz_n1; static float *gapz_n2; static float **cpmx1; static float **cpmx2; static int **intwork; static float **floatwork; static int orlgth1 = 0, orlgth2 = 0; float fpenalty = (float)penalty; #if USE_PENALTY_EX float fpenalty_ex = (float)penalty_ex; #endif float tmppenal; float *fg_t_og_h_dg_n2_p_pt; float *og_t_fg_h_dg_n2_p_pt; float *og_h_dg_n2_p_pt; float *fg_h_dg_n2_p_pt; float *gapz_n2_pt0; float *gapz_n2_pt1; float *fgcp2pt; float *ogcp2pt; float fg_t_og_h_dg_n1_p_va; float og_t_fg_h_dg_n1_p_va; float og_h_dg_n1_p_va; float fg_h_dg_n1_p_va; float gapz_n1_va0; float gapz_n1_va1; float fgcp1va; float ogcp1va; #if 0 fprintf( stderr, "eff in SA+++align\n" ); for( i=0; i<icyc; i++ ) fprintf( stderr, "eff1[%d] = %f\n", i, eff1[i] ); #endif if( orlgth1 == 0 ) { mseq1 = AllocateCharMtx( njob, 0 ); mseq2 = AllocateCharMtx( njob, 0 ); } lgth1 = strlen( seq1[0] ); lgth2 = strlen( seq2[0] ); if( lgth1 > orlgth1 || lgth2 > orlgth2 ) { int ll1, ll2; if( orlgth1 > 0 && orlgth2 > 0 ) { FreeFloatVec( w1 ); FreeFloatVec( w2 ); FreeFloatVec( match ); FreeFloatVec( initverticalw ); FreeFloatVec( lastverticalw ); FreeFloatVec( m ); FreeIntVec( mp ); FreeCharMtx( mseq ); FreeFloatVec( digf1 ); FreeFloatVec( digf2 ); FreeFloatVec( diaf1 ); FreeFloatVec( diaf2 ); FreeFloatVec( gapz1 ); FreeFloatVec( gapz2 ); FreeFloatVec( gapf1 ); FreeFloatVec( gapf2 ); FreeFloatVec( ogcp1g ); FreeFloatVec( ogcp2g ); FreeFloatVec( fgcp1g ); FreeFloatVec( fgcp2g ); FreeFloatVec( og_h_dg_n1_p ); FreeFloatVec( og_h_dg_n2_p ); FreeFloatVec( fg_h_dg_n1_p ); FreeFloatVec( fg_h_dg_n2_p ); FreeFloatVec( og_t_fg_h_dg_n1_p ); FreeFloatVec( og_t_fg_h_dg_n2_p ); FreeFloatVec( fg_t_og_h_dg_n1_p ); FreeFloatVec( fg_t_og_h_dg_n2_p ); FreeFloatVec( gapz_n1 ); FreeFloatVec( gapz_n2 ); FreeFloatMtx( cpmx1 ); FreeFloatMtx( cpmx2 ); FreeFloatMtx( floatwork ); FreeIntMtx( intwork ); } ll1 = MAX( (int)(1.3*lgth1), orlgth1 ) + 100; ll2 = MAX( (int)(1.3*lgth2), orlgth2 ) + 100; #if DEBUG fprintf( stderr, "\ntrying to allocate (%d+%d)xn matrices ... ", ll1, ll2 ); #endif w1 = AllocateFloatVec( ll2+2 ); w2 = AllocateFloatVec( ll2+2 ); match = AllocateFloatVec( ll2+2 ); initverticalw = AllocateFloatVec( ll1+2 ); lastverticalw = AllocateFloatVec( ll1+2 ); m = AllocateFloatVec( ll2+2 ); mp = AllocateIntVec( ll2+2 ); mseq = AllocateCharMtx( njob, ll1+ll2 ); digf1 = AllocateFloatVec( ll1+2 ); digf2 = AllocateFloatVec( ll2+2 ); diaf1 = AllocateFloatVec( ll1+2 ); diaf2 = AllocateFloatVec( ll2+2 ); gapz1 = AllocateFloatVec( ll1+2 ); gapz2 = AllocateFloatVec( ll2+2 ); gapf1 = AllocateFloatVec( ll1+2 ); gapf2 = AllocateFloatVec( ll2+2 ); ogcp1g = AllocateFloatVec( ll1+2 ); ogcp2g = AllocateFloatVec( ll2+2 ); fgcp1g = AllocateFloatVec( ll1+2 ); fgcp2g = AllocateFloatVec( ll2+2 ); og_h_dg_n1_p = AllocateFloatVec( ll1 + 2 ); og_h_dg_n2_p = AllocateFloatVec( ll2 + 2 ); fg_h_dg_n1_p = AllocateFloatVec( ll1 + 2 ); fg_h_dg_n2_p = AllocateFloatVec( ll2 + 2 ); og_t_fg_h_dg_n1_p = AllocateFloatVec( ll1 + 2 ); og_t_fg_h_dg_n2_p = AllocateFloatVec( ll2 + 2 ); fg_t_og_h_dg_n1_p = AllocateFloatVec( ll1 + 2 ); fg_t_og_h_dg_n2_p = AllocateFloatVec( ll2 + 2 ); gapz_n1 = AllocateFloatVec( ll1+2 ); gapz_n2 = AllocateFloatVec( ll2+2 ); cpmx1 = AllocateFloatMtx( 26, ll1+2 ); cpmx2 = AllocateFloatMtx( 26, ll2+2 ); #if FASTMATCHCALC floatwork = AllocateFloatMtx( MAX( ll1, ll2 )+2, 26 ); intwork = AllocateIntMtx( MAX( ll1, ll2 )+2, 26 ); #else floatwork = AllocateFloatMtx( 26, MAX( ll1, ll2 )+2 ); intwork = AllocateIntMtx( 26, MAX( ll1, ll2 )+2 ); #endif #if DEBUG fprintf( stderr, "succeeded\n" ); #endif orlgth1 = ll1 - 100; orlgth2 = ll2 - 100; } for( i=0; i<icyc; i++ ) mseq1[i] = mseq[i]; for( j=0; j<jcyc; j++ ) mseq2[j] = mseq[icyc+j]; if( orlgth1 > commonAlloc1 || orlgth2 > commonAlloc2 ) { int ll1, ll2; if( commonAlloc1 && commonAlloc2 ) { FreeIntMtx( commonIP ); } ll1 = MAX( orlgth1, commonAlloc1 ); ll2 = MAX( orlgth2, commonAlloc2 ); #if DEBUG fprintf( stderr, "\n\ntrying to allocate %dx%d matrices ... ", ll1+1, ll2+1 ); #endif commonIP = AllocateIntMtx( ll1+10, ll2+10 ); #if DEBUG fprintf( stderr, "succeeded\n\n" ); #endif commonAlloc1 = ll1; commonAlloc2 = ll2; } ijp = commonIP; cpmx_calc_new( seq1, cpmx1, eff1, lgth1, icyc ); cpmx_calc_new( seq2, cpmx2, eff2, lgth2, jcyc ); if( sgap1 ) { new_OpeningGapCount_zure( ogcp1g, icyc, seq1, eff1, lgth1, sgap1, egap1 ); new_OpeningGapCount_zure( ogcp2g, jcyc, seq2, eff2, lgth2, sgap2, egap2 ); new_FinalGapCount_zure( fgcp1g, icyc, seq1, eff1, lgth1, sgap1, egap1 ); new_FinalGapCount_zure( fgcp2g, jcyc, seq2, eff2, lgth2, sgap2, egap2 ); getdigapfreq_part( digf1, icyc, seq1, eff1, lgth1, sgap1, egap1 ); getdigapfreq_part( digf2, jcyc, seq2, eff2, lgth2, sgap2, egap2 ); getdiaminofreq_part( diaf1, icyc, seq1, eff1, lgth1, sgap1, egap1 ); getdiaminofreq_part( diaf2, jcyc, seq2, eff2, lgth2, sgap2, egap2 ); getgapfreq( gapf1, icyc, seq1, eff1, lgth1 ); getgapfreq( gapf2, jcyc, seq2, eff2, lgth2 ); getgapfreq_zure_part( gapz1, icyc, seq1, eff1, lgth1, sgap1 ); getgapfreq_zure_part( gapz2, jcyc, seq2, eff2, lgth2, sgap1 ); } else { st_OpeningGapCount( ogcp1g, icyc, seq1, eff1, lgth1 ); st_OpeningGapCount( ogcp2g, jcyc, seq2, eff2, lgth2 ); st_FinalGapCount_zure( fgcp1g, icyc, seq1, eff1, lgth1 ); st_FinalGapCount_zure( fgcp2g, jcyc, seq2, eff2, lgth2 ); getdigapfreq_st( digf1, icyc, seq1, eff1, lgth1 ); getdigapfreq_st( digf2, jcyc, seq2, eff2, lgth2 ); getdiaminofreq_x( diaf1, icyc, seq1, eff1, lgth1 ); getdiaminofreq_x( diaf2, jcyc, seq2, eff2, lgth2 ); getgapfreq( gapf1, icyc, seq1, eff1, lgth1 ); getgapfreq( gapf2, jcyc, seq2, eff2, lgth2 ); getgapfreq_zure( gapz1, icyc, seq1, eff1, lgth1 ); getgapfreq_zure( gapz2, jcyc, seq2, eff2, lgth2 ); } #if 1 lastj = lgth2+2; for( i=0; i<lastj; i++ ) { og_h_dg_n2_p[i] = ( 1.0-ogcp2g[i]-digf2[i] ) * fpenalty * 0.5; fg_h_dg_n2_p[i] = ( 1.0-fgcp2g[i]-digf2[i] ) * fpenalty * 0.5; og_t_fg_h_dg_n2_p[i] = (1.0-ogcp2g[i]+fgcp2g[i]-digf2[i]) * 0.5 * fpenalty; fg_t_og_h_dg_n2_p[i] = (1.0-fgcp2g[i]+ogcp2g[i]-digf2[i]) * 0.5 * fpenalty; gapz_n2[i] = (1.0-gapz2[i]); } lastj = lgth1+2; for( i=0; i<lastj; i++ ) { og_h_dg_n1_p[i] = ( 1.0-ogcp1g[i]-digf1[i] ) * fpenalty * 0.5; fg_h_dg_n1_p[i] = ( 1.0-fgcp1g[i]-digf1[i] ) * fpenalty * 0.5; og_t_fg_h_dg_n1_p[i] = (1.0-ogcp1g[i]+fgcp1g[i]-digf1[i]) * 0.5 * fpenalty; fg_t_og_h_dg_n1_p[i] = (1.0-fgcp1g[i]+ogcp1g[i]-digf1[i]) * 0.5 * fpenalty; gapz_n1[i] = (1.0-gapz1[i]); } #endif currentw = w1; previousw = w2; match_calc( initverticalw, cpmx2, cpmx1, 0, lgth1, floatwork, intwork, 1 ); if( localhom ) part_imp_match_out_vead_tate_gapmapQ( initverticalw, gapmap2[0]+start2, lgth1, start1, gapmap1 ); match_calc( currentw, cpmx1, cpmx2, 0, lgth2, floatwork, intwork, 1 ); if( localhom ) part_imp_match_out_vead_gapmapQ( currentw, gapmap1[0]+start1, lgth2, start2, gapmap2 ); #if 0 // -> tbfast.c if( localhom ) imp_match_calc( currentw, icyc, jcyc, lgth1, lgth2, seq1, seq2, eff1, eff2, localhom, 1, 0 ); #endif if( outgap == 1 ) { g = 0.0; g += ogcp1g[0] * og_h_dg_n2_p[0]; g += ogcp2g[0] * og_h_dg_n1_p[0]; g += fgcp1g[0] * fg_h_dg_n2_p[0]; g += fgcp2g[0] * fg_h_dg_n1_p[0]; initverticalw[0] += g; currentw[0] += g; for( i=1; i<lgth1+1; i++ ) { tmppenal = gapz_n2[0]*og_t_fg_h_dg_n1_p[0]; initverticalw[i] += tmppenal; tmppenal = gapz_n2[1]*fg_t_og_h_dg_n1_p[i]; initverticalw[i] += tmppenal; } for( j=1; j<lgth2+1; j++ ) { tmppenal = gapz_n1[0]*og_t_fg_h_dg_n2_p[0]; currentw[j] += tmppenal; tmppenal = gapz_n1[1]*fg_t_og_h_dg_n2_p[j]; currentw[j] += tmppenal; } } #if OUTGAP0TRY else { for( j=1; j<lgth2+1; j++ ) currentw[j] -= offset * j / 2.0; for( i=1; i<lgth1+1; i++ ) initverticalw[i] -= offset * i / 2.0; } #endif m[0] = 0.0; // iranai for( j=1; j<lgth2+1; ++j ) { mp[j] = 0; m[j] = currentw[j-1] + 10000 * fpenalty; //iinoka? } if( lgth2 == 0 ) lastverticalw[0] = 0.0; // Falign kara yobaretatoki kounarukanousei ari else lastverticalw[0] = currentw[lgth2-1]; if( outgap ) lasti = lgth1+1; else lasti = lgth1; lastj = lgth2+1; #if XXXXXXX fprintf( stderr, "currentw = \n" ); for( i=0; i<lgth1+1; i++ ) { fprintf( stderr, "%5.2f ", currentw[i] ); } fprintf( stderr, "\n" ); fprintf( stderr, "initverticalw = \n" ); for( i=0; i<lgth2+1; i++ ) { fprintf( stderr, "%5.2f ", initverticalw[i] ); } fprintf( stderr, "\n" ); fprintf( stderr, "fcgp\n" ); for( i=0; i<lgth1; i++ ) fprintf( stderr, "fgcp1[%d]=%f\n", i, ogcp1[i] ); for( i=0; i<lgth2; i++ ) fprintf( stderr, "fgcp2[%d]=%f\n", i, ogcp2[i] ); #endif for( i=1; i<lasti; i++ ) { wtmp = previousw; previousw = currentw; currentw = wtmp; previousw[0] = initverticalw[i-1]; match_calc( currentw, cpmx1, cpmx2, i, lgth2, floatwork, intwork, 0 ); #if XXXXXXX fprintf( stderr, "\n" ); fprintf( stderr, "i=%d\n", i ); fprintf( stderr, "currentw = \n" ); for( j=0; j<lgth2; j++ ) { fprintf( stderr, "%5.2f ", currentw[j] ); } fprintf( stderr, "\n" ); #endif if( localhom ) { // fprintf( stderr, "Calling imp_match_calc (o) lgth = %d, i = %d\n", lgth1, i ); // imp_match_out_vead( currentw, i, lgth2 ); part_imp_match_out_vead_gapmapQ( currentw, gapmap1[i]+start1, lgth2, start2, gapmap2 ); } #if XXXXXXX fprintf( stderr, "\n" ); fprintf( stderr, "i=%d\n", i ); fprintf( stderr, "currentw = \n" ); for( j=0; j<lgth2; j++ ) { fprintf( stderr, "%5.2f ", currentw[j] ); } fprintf( stderr, "\n" ); #endif currentw[0] = initverticalw[i]; mpi = 0; mi = previousw[0] + 10000 * fpenalty; ijppt = ijp[i] + 1; mjpt = m + 1; prept = previousw; curpt = currentw + 1; mpjpt = mp + 1; fg_t_og_h_dg_n2_p_pt = fg_t_og_h_dg_n2_p + 1; og_t_fg_h_dg_n2_p_pt = og_t_fg_h_dg_n2_p + 1; og_h_dg_n2_p_pt = og_h_dg_n2_p + 1; fg_h_dg_n2_p_pt = fg_h_dg_n2_p + 1; gapz_n2_pt0 = gapz_n2 + 1; gapz_n2_pt1 = gapz_n2 + 2; fgcp2pt = fgcp2g + 1; ogcp2pt = ogcp2g + 1; fg_t_og_h_dg_n1_p_va = fg_t_og_h_dg_n1_p[i]; og_t_fg_h_dg_n1_p_va = og_t_fg_h_dg_n1_p[i]; og_h_dg_n1_p_va = og_h_dg_n1_p[i]; fg_h_dg_n1_p_va = fg_h_dg_n1_p[i]; gapz_n1_va0 = gapz_n1[i]; gapz_n1_va1 = gapz_n1[i+1]; fgcp1va = fgcp1g[i]; ogcp1va = ogcp1g[i]; for( j=1; j<lastj; j++ ) { wm = *prept; g = ogcp1va * *og_h_dg_n2_p_pt; wm += g; g = *ogcp2pt * og_h_dg_n1_p_va; wm += g; g = fgcp1va * *fg_h_dg_n2_p_pt; wm += g; g = *fgcp2pt * fg_h_dg_n1_p_va; wm += g; *ijppt = 0; #if 0 fprintf( stderr, "%5.0f->", wm ); #endif tmppenal = gapz_n1_va1 * *fg_t_og_h_dg_n2_p_pt; #if 0 fprintf( stderr, "%5.0f?", g ); #endif if( (g=mi+tmppenal) > wm ) { wm = g; *ijppt = -( j - mpi ); } tmppenal = gapz_n1_va0 * *og_t_fg_h_dg_n2_p_pt; if( (g=*prept+tmppenal) >= mi ) { mi = g; mpi = j-1; } #if USE_PENALTY_EX mi += fpenalty_ex; #endif tmppenal = *gapz_n2_pt1 * fg_t_og_h_dg_n1_p_va; #if 0 fprintf( stderr, "%5.0f?", g ); #endif if( (g=*mjpt+tmppenal) > wm ) { wm = g; *ijppt = +( i - *mpjpt ); } tmppenal = *gapz_n2_pt0 * og_t_fg_h_dg_n1_p_va; if( (g=*prept+tmppenal) >= *mjpt ) { *mjpt = g; *mpjpt = i-1; } #if USE_PENALTY_EX m[j] += fpenalty_ex; #endif #if 0 fprintf( stderr, "%5.0f ", wm ); #endif *curpt++ += wm; ijppt++; mjpt++; prept++; mpjpt++; fg_t_og_h_dg_n2_p_pt++; og_t_fg_h_dg_n2_p_pt++; og_h_dg_n2_p_pt++; fg_h_dg_n2_p_pt++; gapz_n2_pt0++; gapz_n2_pt1++; fgcp2pt++; ogcp2pt++; } lastverticalw[i] = currentw[lgth2-1]; } #if OUTGAP0TRY if( !outgap ) { for( j=1; j<lgth2+1; j++ ) currentw[j] -= offset * ( lgth2 - j ) / 2.0; for( i=1; i<lgth1+1; i++ ) lastverticalw[i] -= offset * ( lgth1 - i / 2.0); } #endif /* fprintf( stderr, "\n" ); for( i=0; i<icyc; i++ ) fprintf( stderr,"%s\n", seq1[i] ); fprintf( stderr, "#####\n" ); for( j=0; j<jcyc; j++ ) fprintf( stderr,"%s\n", seq2[j] ); fprintf( stderr, "====>" ); for( i=0; i<icyc; i++ ) strcpy( mseq1[i], seq1[i] ); for( j=0; j<jcyc; j++ ) strcpy( mseq2[j], seq2[j] ); */ if( localhom ) { Atracking_localhom( impmatch, currentw, lastverticalw, seq1, seq2, mseq1, mseq2, cpmx1, cpmx2, ijp, icyc, jcyc, start1, end1, start2, end2, gapmap1, gapmap2 ); } else Atracking( currentw, lastverticalw, seq1, seq2, mseq1, mseq2, cpmx1, cpmx2, ijp, icyc, jcyc ); // fprintf( stderr, "### impmatch = %f\n", *impmatch ); resultlen = strlen( mseq1[0] ); if( alloclen < resultlen || resultlen > N ) { fprintf( stderr, "alloclen=%d, resultlen=%d, N=%d\n", alloclen, resultlen, N ); ErrorExit( "LENGTH OVER!\n" ); } for( i=0; i<icyc; i++ ) strcpy( seq1[i], mseq1[i] ); for( j=0; j<jcyc; j++ ) strcpy( seq2[j], mseq2[j] ); /* fprintf( stderr, "\n" ); for( i=0; i<icyc; i++ ) fprintf( stderr, "%s\n", mseq1[i] ); fprintf( stderr, "#####\n" ); for( j=0; j<jcyc; j++ ) fprintf( stderr, "%s\n", mseq2[j] ); */ // fprintf( stderr, "wm = %f\n", wm ); return( wm ); }