int
main(int argc, char *argv[])
{
    BAR("first test");
    BAR("second test: %s", "a string");
    return 0;
}
예제 #2
0
파일: s1.c 프로젝트: pengkh/proton
int main(void)
{


	BAR("%s", "123456789");
	BAR("%s", "hello");
	BAR("%s", "world");
	BAR("%s", "lenghui1012");
	BAR("f**k you: %d", 100);

	printf("%s\n", json_data);
	printf("%d\n", strlen(json_data));

}
예제 #3
0
파일: test.c 프로젝트: sktwj/var
int main()
{
	FOO(12, 20);
	BAR(1);
	XXPRINTF("my name is %s", "richard");
	return 0;
}
예제 #4
0
int main( void )
/***************/
{
    int     i;
    bool    noneyet;

    /*printf( "extern UINT8 IsArray[] = {\n" );*/
    printf( "/*STRM_MAGIC*/  0,\n" );
    printf( "/*STRM_END  */  0" );      /* note: no ",\n" !! */

    for( i = 0; i <= 255; i++ ) {
        noneyet = true;

        if( isprint( i ) ) {
            printf( ",\n/*   '%c'    */  ", i );
        } else {
            printf( ",\n/*   0x%02x   */  ", i );
        }

        if( isws( i ) ) {
            BAR( IS_WS    );
        }
        if( isprt( i ) ) {
            BAR( IS_PRINT );
        }
        if( isalpha( i ) ) {
            BAR( IS_ALPHA );
        }
        if( isextc( i ) ) {
            BAR( IS_EXTC  );
        }
        if( isdirc( i ) ) {
            BAR( IS_DIRC  );
        }
        if( isfilec( i ) ) {
            BAR( IS_FILEC );
        }
        if( ismacc( i ) ) {
            BAR( IS_MACC );
        }
        if( isbarf( i ) ) {
            BAR( IS_BARF );
        }

        if( noneyet ) {
            printf( "0" );
        }
    }

    /*printf("\n};\n");*/
    printf( "\n" );
    return( 0 );
}
예제 #5
0
int main() {
	int a = 42;
	char *c = BAR(
		__LINE__
	)

	puts(c);
	puts(d);

	puts(__FILE__);
	puts(__func__);
	return __LINE__ + FOO ( 1 + a *, 2 ) + e;
}
예제 #6
0
파일: define.c 프로젝트: ddakhane/c
int main()
{
	if (2 > 4)
		FOO(2)		/* 这里 FOO(2) 后面一定不能添加分号,否则会报错 */
	else
		FOO(4)		/* 这里 FOO(4) 后面可加分号,也可不加,一般是不加 */

	if (2 < 4)
		BAR(2);		/* 这里 BAR(2) 后面一定要加分号,否则会报错 */
	else
		BAR(4)		/* 同时,这里的 BAR(4) 后面也一定要加分号! */
	return 0;
}
예제 #7
0
/* Check if there are any records in the dripback loop left. */
static bool DripBackCheckBusy(landing_dripback2_t *db2)
{
  detref_t              *first;

  /* check if dripback loop is still active */
  while ((first = SNetFifoPeekFirst(&db2->detfifo)) != NULL) {
    BAR();
    if (first->refcount > 0) {
      break;
    }
    SNetFifoGet(&db2->detfifo);
    SNetFifoDone(&first->recfifo);
    SNetDelete(first);
  }

  return first ? true : false;
}
예제 #8
0
/* Process a stolen item. */
static void SNetWorkerLoot(worker_t *worker)
{
  if (worker->loot.desc) {
    if (worker->loot.item) {
      if (worker->loot.count > 0) {
        AAF(&(worker->loot.item->count), worker->loot.count);
      }
      if (trylock_work_item(worker->loot.item, worker)) {
        if (worker->loot.item->count > 0) {
          SNetWorkerWorkItem(worker->loot.item, worker);
        }
        if (worker->loot.item->lock == worker->id) {
          unlock_work_item(worker->loot.item, worker);
        }
      }
    }
    else /* (worker->loot.item == NULL) */ {
      work_item_t *item = GetFreeWorkItem(worker);
      item->next_item = NULL;
      item->next_free = NULL;
      item->desc = worker->loot.desc;
      item->lock = worker->id;
      item->count = worker->loot.count;
      SNetHashPtrStore(worker->hash_ptab, item->desc, item);
      SNetWorkerWorkItem(item, worker);
      if (item->count == 0) {
        if (item->desc) {
          SNetHashPtrRemove(worker->hash_ptab, item->desc);
        }
        item->lock = worker->id;
        PutFreeWorkItem(worker, item);
      } else {
        item->lock = 0;
        item->next_item = worker->prev->next_item;
        BAR();
        worker->prev->next_item = worker->iter = item;
      }
    }
    worker->loot.desc = NULL;
    worker->loot.count = 0;
    worker->loot.item = NULL;
    worker->has_work = (worker->todo.head.next_item != NULL);
  }
}
예제 #9
0
/* Add a new unit of work to the worker's todo list.
 * At return iterator should point to the new item.
 */
void SNetWorkerTodo(worker_t *worker, snet_stream_desc_t *desc)
{
  work_item_t   *item = SNetHashPtrLookup(worker->hash_ptab, desc);

  if (item) {
    /* Item may be locked by a thief. */
    AAF(&item->count, 1);
  } else {
    item = GetFreeWorkItem(worker);
    item->count = 1;
    item->desc = desc;
    item->lock = 0;
    item->next_free = NULL;
    item->next_item = worker->prev->next_item;
    BAR();
    worker->prev->next_item = item;
    worker->prev = item;
    SNetHashPtrStore(worker->hash_ptab, desc, item);
    worker->has_work = true;
  }
}
예제 #10
0
int dCollideBoxPlane (dxGeom *o1, dxGeom *o2,
		      int flags, dContactGeom *contact, int skip)
{
  dxBox *box = (dxBox*) o1;
  dxPlane *plane = (dxPlane*) o2;

  contact->g1 = o1;
  contact->g2 = o2;
  int ret = 0;

  //@@@ problem: using 4-vector (plane->p) as 3-vector (normal).
  const dReal *R = o1->final_posr->R;		// rotation of box
  const dReal *n = plane->p;		// normal vector

  // project sides lengths along normal vector, get absolute values
  dReal Q1 = dDOT14(n,R+0);
  dReal Q2 = dDOT14(n,R+1);
  dReal Q3 = dDOT14(n,R+2);
  dReal A1 = dMUL(box->side[0],Q1);
  dReal A2 = dMUL(box->side[1],Q2);
  dReal A3 = dMUL(box->side[2],Q3);
  dReal B1 = dFabs(A1);
  dReal B2 = dFabs(A2);
  dReal B3 = dFabs(A3);

  // early exit test
  dReal depth = plane->p[3] + dMUL(REAL(0.5),(B1+B2+B3)) - dDOT(n,o1->final_posr->pos);
  if (depth < 0) return 0;

  // find number of contacts requested
  int maxc = flags & NUMC_MASK;
  if (maxc < 1) maxc = 1;
  if (maxc > 3) maxc = 3;	// no more than 3 contacts per box allowed

  // find deepest point
  dVector3 p;
  p[0] = o1->final_posr->pos[0];
  p[1] = o1->final_posr->pos[1];
  p[2] = o1->final_posr->pos[2];
#define FOO(i,op) \
  p[0] op dMUL(REAL(0.5),dMUL(box->side[i],R[0+i])); \
  p[1] op dMUL(REAL(0.5),dMUL(box->side[i],R[4+i])); \
  p[2] op dMUL(REAL(0.5),dMUL(box->side[i],R[8+i]));
#define BAR(i,iinc) if (A ## iinc > 0) { FOO(i,-=) } else { FOO(i,+=) }
  BAR(0,1);
  BAR(1,2);
  BAR(2,3);
#undef FOO
#undef BAR

  // the deepest point is the first contact point
  contact->pos[0] = p[0];
  contact->pos[1] = p[1];
  contact->pos[2] = p[2];
  contact->normal[0] = n[0];
  contact->normal[1] = n[1];
  contact->normal[2] = n[2];
  contact->depth = depth;
  ret = 1;		// ret is number of contact points found so far
  if (maxc == 1) goto done;

  // get the second and third contact points by starting from `p' and going
  // along the two sides with the smallest projected length.

#define FOO(i,j,op) \
  CONTACT(contact,i*skip)->pos[0] = p[0] op dMUL(box->side[j],R[0+j]); \
  CONTACT(contact,i*skip)->pos[1] = p[1] op dMUL(box->side[j],R[4+j]); \
  CONTACT(contact,i*skip)->pos[2] = p[2] op dMUL(box->side[j],R[8+j]);
#define BAR(ctact,side,sideinc) \
  depth -= B ## sideinc; \
  if (depth < 0) goto done; \
  if (A ## sideinc > 0) { FOO(ctact,side,+) } else { FOO(ctact,side,-) } \
  CONTACT(contact,ctact*skip)->depth = depth; \
  ret++;

  CONTACT(contact,skip)->normal[0] = n[0];
  CONTACT(contact,skip)->normal[1] = n[1];
  CONTACT(contact,skip)->normal[2] = n[2];
  if (maxc == 3) {
    CONTACT(contact,2*skip)->normal[0] = n[0];
    CONTACT(contact,2*skip)->normal[1] = n[1];
    CONTACT(contact,2*skip)->normal[2] = n[2];
  }

  if (B1 < B2) {
    if (B3 < B1) goto use_side_3; else {
      BAR(1,0,1);	// use side 1
      if (maxc == 2) goto done;
      if (B2 < B3) goto contact2_2; else goto contact2_3;
    }
  }
  else {
    if (B3 < B2) {
      use_side_3:	// use side 3
      BAR(1,2,3);
      if (maxc == 2) goto done;
      if (B1 < B2) goto contact2_1; else goto contact2_2;
    }
    else {
      BAR(1,1,2);	// use side 2
      if (maxc == 2) goto done;
      if (B1 < B3) goto contact2_1; else goto contact2_3;
    }
  }

  contact2_1: BAR(2,0,1); goto done;
  contact2_2: BAR(2,1,2); goto done;
  contact2_3: BAR(2,2,3); goto done;
#undef FOO
#undef BAR

 done:
  for (int i=0; i<ret; i++) {
    CONTACT(contact,i*skip)->g1 = o1;
    CONTACT(contact,i*skip)->g2 = o2;
  }
  return ret;
}
예제 #11
0
파일: box.cpp 프로젝트: JdeRobot/ThirdParty
int dCollideBoxPlane (dxGeom *o1, dxGeom *o2,
		      int flags, dContactGeom *contact, int skip)
{
  dIASSERT (skip >= (int)sizeof(dContactGeom));
  dIASSERT (o1->type == dBoxClass);
  dIASSERT (o2->type == dPlaneClass);
  dIASSERT ((flags & NUMC_MASK) >= 1);

  dxBox *box = (dxBox*) o1;
  dxPlane *plane = (dxPlane*) o2;

  contact->g1 = o1;
  contact->g2 = o2;
  contact->side1 = -1;
  contact->side2 = -1;
  
  int ret = 0;

  //@@@ problem: using 4-vector (plane->p) as 3-vector (normal).
  const dReal *R = o1->final_posr->R;		// rotation of box
  const dReal *n = plane->p;		// normal vector

  // project sides lengths along normal vector, get absolute values
  dReal Q1 = dCalcVectorDot3_14(n,R+0);
  dReal Q2 = dCalcVectorDot3_14(n,R+1);
  dReal Q3 = dCalcVectorDot3_14(n,R+2);
  dReal A1 = box->side[0] * Q1;
  dReal A2 = box->side[1] * Q2;
  dReal A3 = box->side[2] * Q3;
  dReal B1 = dFabs(A1);
  dReal B2 = dFabs(A2);
  dReal B3 = dFabs(A3);

  // early exit test
  dReal depth = plane->p[3] + REAL(0.5)*(B1+B2+B3) - dCalcVectorDot3(n,o1->final_posr->pos);
  if (depth < 0) return 0;

  // find number of contacts requested
  int maxc = flags & NUMC_MASK;
  // if (maxc < 1) maxc = 1; // an assertion is made on entry
  if (maxc > 4) maxc = 4;	// not more than 4 contacts per box allowed

  // find deepest point
  dVector3 p;
  p[0] = o1->final_posr->pos[0];
  p[1] = o1->final_posr->pos[1];
  p[2] = o1->final_posr->pos[2];
#define FOO(i,op) \
  p[0] op REAL(0.5)*box->side[i] * R[0+i]; \
  p[1] op REAL(0.5)*box->side[i] * R[4+i]; \
  p[2] op REAL(0.5)*box->side[i] * R[8+i];
#define BAR(i,iinc) if (A ## iinc > 0) { FOO(i,-=) } else { FOO(i,+=) }
  BAR(0,1);
  BAR(1,2);
  BAR(2,3);
#undef FOO
#undef BAR

  // the deepest point is the first contact point
  contact->pos[0] = p[0];
  contact->pos[1] = p[1];
  contact->pos[2] = p[2];
  contact->depth = depth;
  ret = 1;		// ret is number of contact points found so far
  if (maxc == 1) goto done;

  // get the second and third contact points by starting from `p' and going
  // along the two sides with the smallest projected length.

#define FOO(i,j,op) \
  CONTACT(contact,i*skip)->pos[0] = p[0] op box->side[j] * R[0+j]; \
  CONTACT(contact,i*skip)->pos[1] = p[1] op box->side[j] * R[4+j]; \
  CONTACT(contact,i*skip)->pos[2] = p[2] op box->side[j] * R[8+j];
#define BAR(ctact,side,sideinc) \
  if (depth - B ## sideinc < 0) goto done; \
  if (A ## sideinc > 0) { FOO(ctact,side,+); } else { FOO(ctact,side,-); } \
  CONTACT(contact,ctact*skip)->depth = depth - B ## sideinc; \
  ret++;

  if (B1 < B2) {
    if (B3 < B1) goto use_side_3; else {
      BAR(1,0,1);	// use side 1
      if (maxc == 2) goto done;
      if (B2 < B3) goto contact2_2; else goto contact2_3;
    }
  }
  else {
    if (B3 < B2) {
      use_side_3:	// use side 3
      BAR(1,2,3);
      if (maxc == 2) goto done;
      if (B1 < B2) goto contact2_1; else goto contact2_2;
    }
    else {
      BAR(1,1,2);	// use side 2
      if (maxc == 2) goto done;
      if (B1 < B3) goto contact2_1; else goto contact2_3;
    }
  }

  contact2_1: BAR(2,0,1); goto done;
  contact2_2: BAR(2,1,2); goto done;
  contact2_3: BAR(2,2,3); goto done;
#undef FOO
#undef BAR

  done:

  if (maxc == 4 && ret == 3) { // If user requested 4 contacts, and the first 3 were created...
    // Combine contacts 2 and 3 (vectorial sum) and get the fourth one
    // Result: if a box face is completely inside a plane, contacts are created for all the 4 vertices
    dReal d4 = CONTACT(contact,1*skip)->depth + CONTACT(contact,2*skip)->depth - depth;  // depth is the depth for first contact
    if (d4 > 0) {
        CONTACT(contact,3*skip)->pos[0] = CONTACT(contact,1*skip)->pos[0] + CONTACT(contact,2*skip)->pos[0] - p[0]; // p is the position of first contact
        CONTACT(contact,3*skip)->pos[1] = CONTACT(contact,1*skip)->pos[1] + CONTACT(contact,2*skip)->pos[1] - p[1];
        CONTACT(contact,3*skip)->pos[2] = CONTACT(contact,1*skip)->pos[2] + CONTACT(contact,2*skip)->pos[2] - p[2];
        CONTACT(contact,3*skip)->depth  = d4;
        ret++;
    }
  }

  for (int i=0; i<ret; i++) {
    dContactGeom *currContact = CONTACT(contact,i*skip);
    currContact->g1 = o1;
    currContact->g2 = o2;
    currContact->side1 = -1;
    currContact->side2 = -1;

    currContact->normal[0] = n[0];
    currContact->normal[1] = n[1];
    currContact->normal[2] = n[2];
  }
  return ret;
}
예제 #12
0
int main(int argc,char *argv[])
{
  //////////////////////////////////////////////////////////////
  //PROGRAM VARIBALES
  //////////////////////////////////////////////////////////////
  char datafile[FSIZE]="",derintfile[FSIZE]="";
  int numcols=0,colx=0,coly=0;
  int i,ndata;

  //////////////////////////////////////////////////////////////
  //INITIALIZE
  //////////////////////////////////////////////////////////////
  TITLE(stdout,'*',"COMPUTE DERIVATIVES AND INTEGRAL OF DATA");

  //////////////////////////////////////////////////////////////
  //SET OPTIONS AND USAGE
  //////////////////////////////////////////////////////////////
  SET_OPTIONS(":hvVf:d:n:x:y:");
  SET_USAGE(
"=======================================================================================\n"
"Usage:\n\n"
"\t./program -f <datafile> [-d <derint_file>] -n <numcols> -x <colx> -y <coly>\n"
"\n"
"Take columns <colx> and <coly> from <datafile> and computes the first\n"
"and second derivative but also the integral in the interval.  The\n"
"results are stored in file <derint_file>\n"
"=======================================================================================\n"
);

  //////////////////////////////////////////////////////////////
  //READ OPTIONS
  //////////////////////////////////////////////////////////////
  while(ITEROPTIONS){
    switch(OPTION){
    case 'f':
      strcpy(datafile,optarg);
      break;
    case 'd':
      strcpy(derintfile,optarg);
      break;
    case 'n':
      numcols=atoi(optarg);
      break;
    case 'x':
      colx=atoi(optarg);
      break;
    case 'y':
      coly=atoi(optarg);
      break;
    //========================================
    //COMMON
    //========================================
    case 'v':
      VERBOSITY=1;
      break;
    case 'V':
      VERBOSITY=2;
      break;
    //DETECT ERRORS
    OPTION_ERRORS;
    }
  }

  //////////////////////////////////////////////////////////////
  //VALIDATE OPTIONS
  //////////////////////////////////////////////////////////////
  if(isBlank(datafile)){
    fprintf(stderr,"Error: No datafile was provided\n");
    PRINT_USAGE;
    EXIT;
  }
  if(!fileExists(datafile)){
    fprintf(stderr,"Error: Datafile '%s' does not exist\n",datafile);
    PRINT_USAGE;
    EXIT;
  }
  if(isBlank(derintfile)){
    sprintf(derintfile,"%s.der",datafile);
  }
  if((ndata=countLines(datafile))==0){
    fprintf(stderr,"Error: Datafile '%s' seems empty\n",datafile);
    PRINT_USAGE;
    EXIT;
  }
  if(numcols<1){
    fprintf(stderr,"Error: The number of columns should be different from 0\n");
    PRINT_USAGE;
    EXIT;
  }
  if(colx==0){
    colx=0;
  }
  if(coly==0){
    coly=1;
  }

  //////////////////////////////////////////////////////////////
  //REPORT INPUT INFORMATION
  //////////////////////////////////////////////////////////////
  if(VERBOSE(1)){
    BAR(stdout,'O');
    fprintf(stdout,"Datafile: %s\n",datafile);
    fprintf(stdout,"Der. Int. file: %s\n",derintfile);
    fprintf(stdout,"Number of columns: %d\n",numcols);
    fprintf(stdout,"Columns x,y: %d,%d\n",colx,coly);
    fprintf(stdout,"Number of points in datafile: %d\n",ndata);
    BAR(stdout,'O');
  }

  //////////////////////////////////////////////////////////////
  //PROGRAM
  //////////////////////////////////////////////////////////////

  //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  //READING DATA
  //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  STPRINTF("Reading %d data points from datafile '%s'...\n",ndata,datafile);
  real *X=readColumns(datafile,ndata,numcols,colx);
  real *Y=readColumns(datafile,ndata,numcols,coly);

  //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  //COMPUTING DERIVATIVES
  //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  STPRINTF("Computing derivatives and integral...\n");
  file fd=fileOpen(derintfile,"w");
  fprintf(fd,"#Datafile: %s\n",datafile);
  fprintf(fd,"#NumberColumns: %d\n",numcols);
  fprintf(fd,"#ColX,ColY: %d %d\n",colx,coly);
  fprintf(fd,"%-14s %-14s %-14s %-14s %-14s\n",
	  "#1:X","2:Y","3:dydx","4:d2ydx2","5:integ");

  real dx,dydx,d2ydx2,integ=0;
  for(i=0;i<ndata;i++){
    if(i==0){
      dx=X[i+1]-X[i];
      dydx=(Y[i+1]-Y[i])/dx;
      d2ydx2=(Y[2]-2*Y[1]+Y[0])/((X[2]-X[0])/2*(X[2]-X[0])/2);
      integ+=(Y[i]+Y[i+1])/2*dx;
    }else if(i==ndata-1){
      dx=X[i]-X[i-1];
      dydx=(Y[i]-Y[i-1])/dx;
      d2ydx2=(Y[ndata-1]-2*Y[ndata-2]+Y[ndata-3])/
	((X[ndata-1]-X[ndata-3])/2*(X[ndata-1]-X[ndata-3])/2);
      integ+=(Y[i]+Y[i-1])/2*dx;
    }else{
      dx=X[i+1]-X[i-1];
      dydx=(Y[i+1]-Y[i-1])/dx;
      d2ydx2=(Y[i+1]-2*Y[i]+Y[i-1])/(dx/2*dx/2);
      integ+=(Y[i+1]+Y[i-1])/2*(dx/2);
    }
    fprintf(fd,"%+14.7e %+14.7e %+14.7e %+14.7e %+14.7e\n",
	    X[i],Y[i],dydx,d2ydx2,integ);
  }
  fclose(fd);
  STPRINTF("Done.\n");
  
  return 0;
}
예제 #13
0
int_triple THD_orient_guess( MRI_IMAGE *imm )
{
   int nvox , ii , nx,ny,nxy,nz , ix,jy,kz , icm,jcm,kcm , nbar ;
   byte *bar , bp,bm ;
   float xcm , ycm , zcm , ff , dx,dy,dz ;
   float xx,yy,zz ;
   int ni,nj,nk , itop,jtop,ktop , im,ip , jm,jp , km,kp ;
   float axx,ayy,azz , clip  , qx,qy,qz , arr[3] ;
   int d_LR , d_AP , d_IS ;

   int_triple it = {-1,-1,-1} ;

   /*-- check for bad input --*/

   if( imm == NULL || imm->nx < 5 || imm->ny < 5 || imm->nz < 5 ) return it ;

   nx = imm->nx; ny = imm->ny; nz = imm->nz; nxy = nx*ny; nvox = nx*ny*nz;

   dx = fabs(imm->dx) ; if( dx == 0.0 ) dx = 1.0 ;
   dy = fabs(imm->dy) ; if( dy == 0.0 ) dy = 1.0 ;
   dz = fabs(imm->dz) ; if( dz == 0.0 ) dz = 1.0 ;

   /*-- make mask of NPER levels --*/

   bar  = (byte *) malloc( sizeof(byte) * nvox ) ;
   clip = THD_cliplevel( imm , 0.5 ) ;

   /* start with a binary mask */

   switch( imm->kind ){
     case MRI_float:{
       float *ar = MRI_FLOAT_PTR(imm) ;
       for( ii=0 ; ii < nvox ; ii++ ) bar[ii] = (ar[ii] >= clip);
     }
     break ;
     case MRI_short:{
       short *ar = MRI_SHORT_PTR(imm) ;
       for( ii=0 ; ii < nvox ; ii++ ) bar[ii] = (ar[ii] >= clip);
     }
     break ;
     case MRI_byte:{
       byte *ar = MRI_BYTE_PTR(imm) ;
       for( ii=0 ; ii < nvox ; ii++ ) bar[ii] = (ar[ii] >= clip);
     }
     break ;
   }

   nbar = THD_countmask(nvox,bar) ;
   printf("%d voxels in initial binary mask\n",nbar) ;
   if( nbar == 0 ){ free(bar); return it; }  /* bad */

   THD_mask_clust( nx,ny,nz , bar ) ;      /* take biggest cluster */

   nbar = THD_countmask(nvox,bar) ;
   printf("%d voxels in final binary mask\n",nbar) ;

#ifdef NPER
 if( nper > 1 ){
   float per[NPER+1] ; MRI_IMAGE *qim ; int jj ;
   qim = mri_new( nbar , 1 , imm->kind ) ;
   switch(imm->kind){
     case MRI_float:{
      float *ar=MRI_FLOAT_PTR(imm) , *qar=MRI_FLOAT_PTR(qim) ;
      for( jj=ii=0 ; ii < nvox ; ii++ ) if( bar[ii] ) qar[jj++] = ar[ii] ;
     }
     break ;
     case MRI_short:{
      short *ar=MRI_SHORT_PTR(imm) , *qar=MRI_SHORT_PTR(qim) ;
      for( jj=ii=0 ; ii < nvox ; ii++ ) if( bar[ii] ) qar[jj++] = ar[ii] ;
     }
     break ;
     case MRI_byte:{
      byte *ar=MRI_BYTE_PTR(imm) , *qar=MRI_BYTE_PTR(qim) ;
      for( jj=ii=0 ; ii < nvox ; ii++ ) if( bar[ii] ) qar[jj++] = ar[ii] ;
     }
     break ;
   }
   printf("call mri_percents\n") ;
   mri_percents( qim , nper , per ) ;  /* compute nper break points */
   mri_free(qim) ;
   printf("per:") ;
   for( ii=0 ; ii <= nper ; ii++ ) printf(" %g",per[ii]) ;
   printf("\n") ;
   switch( imm->kind ){
     case MRI_float:{
       float *ar = MRI_FLOAT_PTR(imm) , val ;
       for( ii=0 ; ii < nvox ; ii++ ){
         if( bar[ii] ){
           val = ar[ii] ;
           for( jj=1 ; jj <= nper && val >= per[jj] ; jj++ ) ; /*spin*/
           bar[ii] = jj ;
         }
       }
     }
     break ;
     case MRI_short:{
       short *ar = MRI_SHORT_PTR(imm) , val ;
       for( ii=0 ; ii < nvox ; ii++ ){
         if( bar[ii] ){
           val = ar[ii] ;
           for( jj=1 ; jj <= nper && val >= per[jj] ; jj++ ) ; /*spin*/
           bar[ii] = jj ;
         }
       }
     }
     break ;
     case MRI_byte:{
       byte *ar = MRI_BYTE_PTR(imm) , val ;
       for( ii=0 ; ii < nvox ; ii++ ){
         if( bar[ii] ){
           val = ar[ii] ;
           for( jj=1 ; jj <= nper && val >= per[jj] ; jj++ ) ; /*spin*/
           bar[ii] = jj ;
         }
       }
     }
     break ;
   }
  }
#endif  /* NPER */

   /* find center of mass of mask */

   xcm = ycm = zcm = ff = 0.0 ;
   for( ii=0 ; ii < nvox ; ii++ ){
     if( bar[ii] ){
       ix = (ii % nx)      ; xx = ix*dx ; xcm += xx*bar[ii] ;
       jy = (ii / nx) % ny ; yy = jy*dy ; ycm += yy*bar[ii] ;
       kz = (ii /nxy)      ; zz = kz*dz ; zcm += zz*bar[ii] ;
       ff += bar[ii] ;
     }
   }
   xcm /= ff ; ycm /= ff ; zcm /= ff ;

   icm = rint(xcm/dx) ;
   itop = 2*icm ; if( itop >= nx ) itop = nx-1 ;
   ni  = itop-icm ;

   jcm = rint(ycm/dy) ;
   jtop = 2*jcm ; if( jtop >= ny ) jtop = ny-1 ;
   nj  = jtop-jcm ;

   kcm = rint(zcm/dz) ;
   ktop = 2*kcm ; if( ktop >= nz ) ktop = nz-1 ;
   nk  = ktop-kcm ;

   printf("Mask count = %d\n"
          "icm = %d  jcm = %d  kcm = %d\n"
          "ni  = %d  nj  = %d  nk  = %d\n",
          (int)ff , icm,jcm,kcm , ni,nj,nk ) ;

   /** compute asymmetry measures about CM voxel **/

#define BAR(i,j,k) bar[(i)+(j)*nx+(k)*nxy]

   axx = 0.0 ;
   for( ix=1 ; ix <= ni ; ix++ ){
     im = icm-ix ; ip = icm+ix ;
     for( kz=kcm-nk ; kz <= kcm+nk ; kz++ ){
       for( jy=jcm-nj ; jy <= jcm+nj ; jy++ )
         axx += abs(BAR(ip,jy,kz) - BAR(im,jy,kz)) ;
     }
   }
   axx /= (ni*nj*nk) ; printf("axx = %g\n",axx) ;

   ayy = 0.0 ;
   for( jy=1 ; jy <= nj ; jy++ ){
     jm = jcm-jy ; jp = jcm+jy ;
     for( kz=kcm-nk ; kz <= kcm+nk ; kz++ ){
       for( ix=icm-ni ; ix <= icm+ni ; ix++ )
         ayy += abs(BAR(ix,jp,kz) - BAR(ix,jm,kz)) ;
     }
   }
   ayy /= (ni*nj*nk) ; printf("ayy = %g\n",ayy) ;

   azz = 0.0 ;
   for( kz=1 ; kz <= nk ; kz++ ){
     km = kcm-kz ; kp = kcm+kz ;
     for( jy=jcm-nj ; jy <= jcm+nj ; jy++ ){
       for( ix=icm-ni ; ix <= icm+ni ; ix++ )
         azz += abs(BAR(ix,jy,kp) - BAR(ix,jy,km)) ;
     }
   }
   azz /= (ni*nj*nk) ; printf("azz = %g\n",azz) ;

   /** least asymettric is L-R direction **/

   if( axx < ayy ){
     if( axx < azz ) d_LR = 1 ;
     else            d_LR = 3 ;
   } else {
     if( ayy < azz ) d_LR = 2 ;
     else            d_LR = 3 ;
   }
   printf("axis %d is L-R\n",d_LR) ;

   arr[0] = axx ; arr[1] = ayy ; arr[2] = azz ; ff = arr[d_LR-1] ;
   arr[0] /= ff ;
   arr[1] /= ff ;
   arr[2] /= ff ;
   printf("a ratios = %g  %g  %g\n",arr[0],arr[1],arr[2]) ;

   /** find asymmetry measures in 1/2 spaces perp to L-R **/

   switch( d_LR ){

     case 3:{  /* L-R is z-axis */
       float axx_jp=0.0, axx_jm=0.0, ayy_ip=0.0, ayy_im=0.0 ;
       for( ix=1 ; ix <= ni ; ix++ ){
         im = icm-ix ; ip = icm+ix ;
         for( kz=kcm-nk ; kz <= kcm+nk ; kz++ ){
           for( jy=1 ; jy <= nj ; jy++ ){
             axx_jp += abs(BAR(ip,jcm+jy,kz) - BAR(im,jcm+jy,kz)) ;
             axx_jm += abs(BAR(ip,jcm-jy,kz) - BAR(im,jcm-jy,kz)) ;
           }
         }
       }
       for( jy=1 ; jy <= nj ; jy++ ){
         jm = jcm-jy ; jp = jcm+jy ;
         for( kz=kcm-nk ; kz <= kcm+nk ; kz++ ){
           for( ix=1 ; ix <= ni ; ix++ ){
             ayy_ip += abs(BAR(icm+ix,jp,kz) - BAR(icm+ix,jm,kz)) ;
             ayy_im += abs(BAR(icm-ix,jp,kz) - BAR(icm-ix,jm,kz)) ;
           }
         }
       }
       axx_jp /= (ni*nj*nk) ; axx_jm /= (ni*nj*nk) ;
       ayy_ip /= (ni*nj*nk) ; ayy_im /= (ni*nj*nk) ;

       printf("axx_jp=%g  axx_jm=%g  ayy_ip=%g  ayy_im=%g\n",
               axx_jp,axx_jm , ayy_ip,ayy_im ) ;
     } /* end of case 3 */
     break ;

   }

   return it ;
}
예제 #14
0
int main(int argc, char **argv)
{
   /* Declare vars. */
   CDKSCREEN *cdkscreen = 0;
   CDKHISTOGRAM *volume = 0;
   CDKHISTOGRAM *bass	= 0;
   CDKHISTOGRAM *treble = 0;
   WINDOW *cursesWin	= 0;
   char *volumeTitle	= "<C></5>Volume<!5>";
   char *bassTitle	= "<C></5>Bass  <!5>";
   char *trebleTitle	= "<C></5>Treble<!5>";

   CDK_PARAMS params;
   boolean Box;

   CDKparseParams(argc, argv, &params, CDK_CLI_PARAMS);
   Box = CDKparamValue(&params, 'N', TRUE);

   /* Set up CDK. */
   cursesWin = initscr();
   cdkscreen = initCDKScreen (cursesWin);

   /* Start CDK Color. */
   initCDKColor();

   /* Create the histogram objects. */
   volume = newCDKHistogram (cdkscreen,
			     CDKparamValue(&params, 'X', 10),
			     CDKparamValue(&params, 'Y', 10),
			     CDKparamValue(&params, 'H', 1),
			     CDKparamValue(&params, 'W', -2),
			     HORIZONTAL, volumeTitle,
			     Box,
			     CDKparamValue(&params, 'S', FALSE));
   if (volume == 0)
   {
      /* Exit CDK. */
      destroyCDKScreen (cdkscreen);
      endCDK();

      /* Print out a message and exit. */
      printf ("Oops. Can not make volume histogram. Is the window big enough??\n");
      ExitProgram (EXIT_FAILURE);
   }

   bass = newCDKHistogram (cdkscreen,
			   CDKparamValue(&params, 'X', 10),
			   CDKparamValue(&params, 'Y', 14),
			   CDKparamValue(&params, 'H', 1),
			   CDKparamValue(&params, 'W', -2),
			   HORIZONTAL, bassTitle,
			   Box,
			   CDKparamValue(&params, 'S', FALSE));
   if (bass == 0)
   {
      /* Exit CDK. */
      destroyCDKHistogram (volume);
      destroyCDKScreen (cdkscreen);
      endCDK();

      /* Print out a message and exit. */
      printf ("Oops. Can not make bass histogram. Is the window big enough??\n");
      ExitProgram (EXIT_FAILURE);
   }

   treble = newCDKHistogram (cdkscreen,
			     CDKparamValue(&params, 'X', 10),
			     CDKparamValue(&params, 'Y', 18),
			     CDKparamValue(&params, 'H', 1),
			     CDKparamValue(&params, 'W', -2),
			     HORIZONTAL, trebleTitle,
			     Box,
			     CDKparamValue(&params, 'S', FALSE));
   if (treble == 0)
   {
      /* Exit CDK. */
      destroyCDKHistogram (volume);
      destroyCDKHistogram (bass);
      destroyCDKScreen (cdkscreen);
      endCDK();

      /* Print out a message and exit. */
      printf ("Oops. Can not make treble histogram. Is the window big enough??\n");
      ExitProgram (EXIT_FAILURE);
   }

#define BAR(a,b,c) A_BOLD, a, b, c, ' '|A_REVERSE|COLOR_PAIR(3), Box

   /* Set the histogram values. */
   setCDKHistogram (volume, vPERCENT, CENTER, BAR(0, 10, 6));
   setCDKHistogram (bass  , vPERCENT, CENTER, BAR(0, 10, 3));
   setCDKHistogram (treble, vPERCENT, CENTER, BAR(0, 10, 7));
   refreshCDKScreen (cdkscreen);
   sleep (4);

   /* Set the histogram values. */
   setCDKHistogram (volume, vPERCENT, CENTER, BAR(0, 10, 8));
   setCDKHistogram (bass  , vPERCENT, CENTER, BAR(0, 10, 1));
   setCDKHistogram (treble, vPERCENT, CENTER, BAR(0, 10, 9));
   refreshCDKScreen (cdkscreen);
   sleep (4);

   /* Set the histogram values. */
   setCDKHistogram (volume, vPERCENT, CENTER, BAR(0, 10, 10));
   setCDKHistogram (bass  , vPERCENT, CENTER, BAR(0, 10, 7));
   setCDKHistogram (treble, vPERCENT, CENTER, BAR(0, 10, 10));
   refreshCDKScreen (cdkscreen);
   sleep (4);

   /* Set the histogram values. */
   setCDKHistogram (volume, vPERCENT, CENTER, BAR(0, 10, 1));
   setCDKHistogram (bass  , vPERCENT, CENTER, BAR(0, 10, 8));
   setCDKHistogram (treble, vPERCENT, CENTER, BAR(0, 10, 3));
   refreshCDKScreen (cdkscreen);
   sleep (4);

   /* Set the histogram values. */
   setCDKHistogram (volume, vPERCENT, CENTER, BAR(0, 10, 3));
   setCDKHistogram (bass  , vPERCENT, CENTER, BAR(0, 10, 3));
   setCDKHistogram (treble, vPERCENT, CENTER, BAR(0, 10, 3));
   refreshCDKScreen (cdkscreen);
   sleep (4);

   /* Set the histogram values. */
   setCDKHistogram (volume, vPERCENT, CENTER, BAR(0, 10, 10));
   setCDKHistogram (bass  , vPERCENT, CENTER, BAR(0, 10, 10));
   setCDKHistogram (treble, vPERCENT, CENTER, BAR(0, 10, 10));
   refreshCDKScreen (cdkscreen);
   sleep (4);

   /* Clean up. */
   destroyCDKHistogram (volume);
   destroyCDKHistogram (bass);
   destroyCDKHistogram (treble);
   destroyCDKScreen (cdkscreen);
   endCDK();
   ExitProgram (EXIT_SUCCESS);
}
예제 #15
0
int main () {
  int i = 0;
  return BAR(i);
}
예제 #16
0
파일: map2dist.cpp 프로젝트: facom/Dynamo
int main(int argc,char *argv[])
{
  //////////////////////////////////////////////////////////////
  //PROGRAM VARIBALES
  //////////////////////////////////////////////////////////////
  char mapfile[FSIZE]="",distfile[FSIZE]="",type[2]="";
  char ctype,coper='s';
  int cx=0,cy=1;
  
  //////////////////////////////////////////////////////////////
  //INITIALIZE
  //////////////////////////////////////////////////////////////
  TITLE(stdout,'*',"COMPUTE A SCALAR MAP");

  //////////////////////////////////////////////////////////////
  //SET OPTIONS AND USAGE
  //////////////////////////////////////////////////////////////
  SET_OPTIONS(":hvVm:d:t:o:x:y:");
  SET_USAGE(
"============================================================================\n"
"Usage:\n"
"\n"
"\t./program -m <mapfile> [-d <distfile>] -t <type_dist> [-o <type_oper>]\n"
"\t                        -x <direction_x> [-y <direction_y>]\n"
/*

Collapse the information in the <mapfile>.  Collapsing a map means to
produce a 2-D or a 1-D (<type_dist>: 1D or 2D) from a full 3-D map.
What collapse do is to take a given direction in the grid and apply
over all the cells in that direction an operation (<type_oper>: sum,
average).  

You can indicate the directions that should be preserved
(<direction_x> and/or <direction_y>).  

 */
"\n"
"=========================================================================\n"
);

  //////////////////////////////////////////////////////////////
  //READ OPTIONS
  //////////////////////////////////////////////////////////////
  while(ITEROPTIONS){
    switch(OPTION){
    case 'm':
      strcpy(mapfile,optarg);
      break;
    case 'd':
      strcpy(distfile,optarg);
      break;
    case 't':
      strcpy(type,optarg);
      break;
    case 'o':
      coper=optarg[0];
      break;
    case 'x':
      cx=atoi(optarg);
      break;
    case 'y':
      cy=atoi(optarg);
      break;
    //========================================
    //COMMON
    //========================================
    case 'v':
      VERBOSITY=1;
      break;
    case 'V':
      VERBOSITY=2;
      break;
    //DETECT ERRORS
    OPTION_ERRORS;
    }
  }

  //////////////////////////////////////////////////////////////
  //VALIDATE OPTIONS
  //////////////////////////////////////////////////////////////
  if(isBlank(mapfile)){
    fprintf(stderr,"Error: No mapfile was provided\n");
    PRINT_USAGE;
    EXIT;
  }
  if(!fileExists(mapfile)){
    fprintf(stderr,"Error: Mapfile '%s' does not exist\n",mapfile);
    PRINT_USAGE;
    EXIT;
  }
  if(isBlank(distfile)){
    sprintf(distfile,"%s.dst",mapfile);
  }
  if(isBlank(type)){
    strcpy(type,"1D");
  }
  ctype=type[0];
  if(ctype=='2'){
    if(cx==cy){
      fprintf(stderr,"Error: x(%d) and y(%d) cannot be equal\n",cx,cy,mapfile);
      PRINT_USAGE;
      EXIT;
    }
  }else{
    cy=(cx+1)%3;
  }
  
  //////////////////////////////////////////////////////////////
  //REPORT INPUT INFORMATION
  //////////////////////////////////////////////////////////////
  if(VERBOSE(1)){
    BAR(stdout,'O');
    fprintf(stdout,"Map file: %s\n",mapfile);
    fprintf(stdout,"Distributuion file: %s\n",distfile);
    fprintf(stdout,"Type of distribution: %s\n",type);
    fprintf(stdout,"Type of operation: %c\n",coper);
    fprintf(stdout,"X column: %d\n",cx);
    if(ctype!='2')
      fprintf(stdout,"Y column: %d\n",cy);
    BAR(stdout,'O');
  }

  //////////////////////////////////////////////////////////////
  //PROGRAM
  //////////////////////////////////////////////////////////////
  int i,j,k,n,p;
  char linea[LSIZE],ctmp[LSIZE];
  int nx,ny,nz;
  real *fieldmap;
  real x,y,z;
  real C[3][MAXGRID];
  int ix,iy,iz;
  int ndx,ndy,ndz;

  //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  //READ MAP FILE
  //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  STPRINTF("Getting data from mapfile '%s'...\n",mapfile);
  file fm=fopen(mapfile,"r");
  
  //Read header
  for(i=1;i<=6;i++)
    fgets(linea,sizeof linea,fm);

  //Get number of data points in the grid
  fgets(linea,sizeof linea,fm);
  sscanf(linea,"%s %d %d %d",ctmp,&nx,&ny,&nz);
  fieldmap=(real*)calloc(nx*ny*nz,sizeof(real));
  
  //Read data points
  fgets(linea,sizeof linea,fm);
  n=0;
  for(k=0;k<nz;k++){
    for(i=0;i<nx;i++){
      for(j=0;j<ny;j++){
	p=i+j*nx+k*nx*ny;
	fgets(linea,sizeof linea,fm);n++;
	//fprintf(stdout,"DATA LINEA %d: %s",n,linea);
	sscanf(linea,"%f %f %f %f",
	       &x,&y,&z,&fieldmap[p]);
	//fprintf(stdout,"%d %d %d : %d = %g\n",i,j,k,p,fieldmap[p]);
	C[1][j]=y;
      }
      C[0][i]=x;
      //Blank line
      fgets(linea,sizeof linea,fm);n++;
      //fprintf(stdout,"LINEA %d: %s",n,linea);
    }
    C[2][k]=z;
    //Blank line
    fgets(linea,sizeof linea,fm);n++;
    //fprintf(stdout,"LINEA %d: %s",n,linea);
  }
  fclose(fm);
  
  /*
  fprintf(stdout,"X:");
  arrayPrintf(stdout,"%.2e ",C[0],nx);
  fprintf(stdout,"\n");

  fprintf(stdout,"Y:");
  arrayPrintf(stdout,"%.2e ",C[1],ny);
  fprintf(stdout,"\n");

  fprintf(stdout,"Z:");
  arrayPrintf(stdout,"%.2e ",C[2],nz);
  fprintf(stdout,"\n");
  */

  //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  //COLLAPSE DATA
  //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  STPRINTF("Collapsing data...\n");
  real XDIST[MAXGRID],YDIST[MAXGRID];
  real distmap[MAXGRID][MAXGRID];
  
  switch(cx){
  case 0:
    ndx=nx;ix=0;
    switch(cy){
    case 1:
      ndy=ny;iy=1;
      ndz=nz;iz=2;
      break;
    case 2:
      ndy=nz;iy=2;
      ndz=ny;iz=1;
      break;
    }
    break;
  case 1:
    ndx=ny;ix=1;
    switch(cy){
    case 0:
      ndy=nx;iy=0;
      ndz=nz;iz=2;
      break;
    case 2:
      ndy=nz;iy=2;
      ndz=nx;iz=0;
      break;
    }
    break;
  case 2:
    ndx=nz;ix=2;
    switch(cy){
    case 0:
      ndy=nx;iy=0;
      ndz=ny;iz=1;
      break;
    case 1:
      ndy=ny;iy=1;
      ndz=nx;iz=0;
      break;
    }
    break;
  }
  /*
  fprintf(stdout,"ix,iy,iz: %d,%d,%d\n",ix,iy,iz);
  fprintf(stdout,"nx,ny,nz: %d,%d,%d\n",ndx,ndy,ndz);
  */

  /*
  i=1;j=3;k=2;
  p=positionDist(ix,iy,iz,i,j,k,nx,ny,nz);
  fprintf(stdout,"ENTRY (%d,%d,%d:%d): %e\n",i,j,k,p,fieldmap[p]);
  exit(0);
  //*/

  switch(ctype){
  case '1':
    for(i=0;i<ndx;i++){
      XDIST[i]=C[ix][i];
      //fprintf(stdout,"CONST %d: %g\n",i,XDIST[i]);
      distmap[i][0]=0;
      for(j=0;j<ndy;j++){
	for(k=0;k<ndz;k++){
	  p=positionDist(ix,iy,iz,i,j,k,nx,ny,nz);
	  /*
	  fprintf(stdout,"\tSumming up %d:%d,%d:%d,%d:%d = %d: %g\n",
		  ix,i,iy,j,iz,k,p,fieldmap[p]);
	  */
	  distmap[i][0]+=fieldmap[p];
	}
      }
      if(coper=='a') distmap[i][0]/=(ndy*ndz);
    }
    break;
  case '2':
    for(i=0;i<ndx;i++){
      XDIST[i]=C[ix][i];
      for(j=0;j<ndy;j++){
	YDIST[j]=C[iy][j];
	distmap[i][j]=0;
	for(k=0;k<ndz;k++){
	  p=positionDist(ix,iy,iz,i,j,k,nx,ny,nz);
	  distmap[i][j]+=fieldmap[p];
	}
	if(coper=='a') distmap[i][j]/=ndz;
      }
    }
    break;
  }

  //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  //STORE DISTRIBUTION
  //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  STPRINTF("Storing distribution in file '%s'...\n",distfile);
  file fd=fileOpen(distfile,"w");
  
  fprintf(fd,"#MapFile: %s\n",mapfile);
  fprintf(fd,"#TypeDist: %s\n",type);

  switch(ctype){
  case '1':
    fprintf(fd,"#ColapseDirections: %d\n",cx);
    fprintf(fd,"%-14s %-14s\n","#1:X","2:DIST");
    for(i=0;i<ndx;i++){
      //fprintf(fd,"%+14.7e %+14.7e\n",XDIST[i],distmap[i][0]);
      fprintf(fd,"%+14.7e %g\n",XDIST[i],distmap[i][0]);
    }
    break;
  case '2':
    fprintf(fd,"#ColapseDirections: %d %d\n",cx,cy);
    fprintf(fd,"%-14s %-14s\t%-14s\n","#1:X","2:Y","3:DIST");
    for(i=0;i<ndx;i++){
      for(j=0;j<ndy;j++){
	//fprintf(fd,"%+14.7e %+14.7e\t%+14.7e\n",XDIST[i],YDIST[j],distmap[i][j]);
	fprintf(fd,"%+14.7e %+14.7e\t%g\n",XDIST[i],YDIST[j],distmap[i][j]);
      }
      fprintf(fd,"\n");
    }
    break;
  }  

  return 0;
}