示例#1
0
    vector<Cross> createCrossingList()
    {

        vector<Cross> crosslist;
        ParticleGrid<Particle>::GridArray *g = pcontainer.getVoxelGridArray();
        for (int i = 0;i < g->gridsize;i++)
        {
               if (g->occnt[i] > 0)
               {
                   for (int k = 0; k < g->occnt[i]; k++)
                   {
                       Particle *p1 = g->grid[g->csize*i+ k];
                       for (int j = k+1; j < g->occnt[i]; j++)
                       {
                            Particle *p2 = g->grid[g->csize*i+ j];
                            
                            Cross x;
                            x.i = p1->label;
                            x.j = p2->label;
                            x.wi = p1->w;
                            x.wj = p2->w;
                            crosslist.push_back(x);                            
                       }
                   }
               }
                
        }
        return crosslist;

            
    }
示例#2
0
    // write out to MATLAB
	void writeout(REAL *npoints)
	{
	
		for (int k = 0; k < pcontainer.pcnt; k++)
		{
			Particle *p = &(pcontainer.particles[k]);
			npoints[attrcnt*k] = p->R.x;
			npoints[attrcnt*k+1] = p->R.y;
			npoints[attrcnt*k+2] = p->R.z;
			npoints[attrcnt*k+3] = p->N.x;
			npoints[attrcnt*k+4] = p->N.y;
			npoints[attrcnt*k+5] = p->N.z;
			npoints[attrcnt*k+6] = p->label;	
			npoints[attrcnt*k+7] = p->len;		
			npoints[attrcnt*k+8] = pcontainer.ID_2_index(p->mID);		
			npoints[attrcnt*k+9] = pcontainer.ID_2_index(p->pID);		
			npoints[attrcnt*k+10] = p->Di;
			npoints[attrcnt*k+11] = p->Da;
			npoints[attrcnt*k+12] = p->Dp;
			npoints[attrcnt*k+13] = p->w;
			npoints[attrcnt*k+14] = p->q;                    
                    

		}
	

	}
示例#3
0
 void WriteOutParticles(float *npoints)
 {
   for (int k = 0; k < m_ParticleGrid.pcnt; k++)
   {
     Particle *p = &(m_ParticleGrid.particles[k]);
     npoints[m_NumAttributes*k] = p->R.GetX();
     npoints[m_NumAttributes*k+1] = p->R.GetY();
     npoints[m_NumAttributes*k+2] = p->R.GetZ();
     npoints[m_NumAttributes*k+3] = p->N.GetX();
     npoints[m_NumAttributes*k+4] = p->N.GetY();
     npoints[m_NumAttributes*k+5] = p->N.GetZ();
     npoints[m_NumAttributes*k+6] = p->cap;
     npoints[m_NumAttributes*k+7] = p->len;
     npoints[m_NumAttributes*k+8] = m_ParticleGrid.ID_2_index(p->mID);
     npoints[m_NumAttributes*k+9] = m_ParticleGrid.ID_2_index(p->pID);
   }
 }
示例#4
0
void
GibbsTrackingFilter< ItkQBallImageType >
::EstimateParticleWeight()
{
    MITK_INFO << "GibbsTrackingFilter: estimating particle weight";

    float minSpacing;
    if(m_QBallImage->GetSpacing()[0]<m_QBallImage->GetSpacing()[1] && m_QBallImage->GetSpacing()[0]<m_QBallImage->GetSpacing()[2])
        minSpacing = m_QBallImage->GetSpacing()[0];
    else if (m_QBallImage->GetSpacing()[1] < m_QBallImage->GetSpacing()[2])
        minSpacing = m_QBallImage->GetSpacing()[1];
    else
        minSpacing = m_QBallImage->GetSpacing()[2];
    float m_ParticleLength = 1.5*minSpacing;
    float m_ParticleWidth = 0.5*minSpacing;

    // seed random generators
    Statistics::MersenneTwisterRandomVariateGenerator::Pointer randGen = Statistics::MersenneTwisterRandomVariateGenerator::New();
    if (m_RandomSeed>-1)
        randGen->SetSeed(m_RandomSeed);
    else
        randGen->SetSeed();

    // instantiate all necessary components
    SphereInterpolator* interpolator = new SphereInterpolator(m_LutPath);
    // handle lookup table not found cases
    if( !interpolator->IsInValidState() )
    {
      m_IsInValidState = false;
      m_AbortTracking = true;
      m_BuildFibers = false;
      mitkThrow() << "Unable to load lookup tables.";
    }
    ParticleGrid* particleGrid = new ParticleGrid(m_MaskImage, m_ParticleLength, m_ParticleGridCellCapacity);
    GibbsEnergyComputer* encomp = new GibbsEnergyComputer(m_QBallImage, m_MaskImage, particleGrid, interpolator, randGen);

    //    EnergyComputer* encomp = new EnergyComputer(m_QBallImage, m_MaskImage, particleGrid, interpolator, randGen);
    MetropolisHastingsSampler* sampler = new MetropolisHastingsSampler(particleGrid, encomp, randGen, m_CurvatureThreshold);

    float alpha = log(m_EndTemperature/m_StartTemperature);
    m_ParticleWeight = 0.01;
    int ppv = 0;
    // main loop
    int neededParts = 3000;
    while (ppv<neededParts)
    {
        if (ppv<1000)
            m_ParticleWeight /= 2;
        else
            m_ParticleWeight = ppv*m_ParticleWeight/neededParts;

        encomp->SetParameters(m_ParticleWeight,m_ParticleWidth,m_ConnectionPotential*m_ParticleLength*m_ParticleLength,m_CurvatureThreshold,m_InexBalance,m_ParticlePotential);
        for( int step = 0; step < 10; step++ )
        {
            // update temperatur for simulated annealing process
            float temperature = m_StartTemperature * exp(alpha*(((1.0)*step)/((1.0)*10)));
            sampler->SetTemperature(temperature);

            for (unsigned long i=0; i<10000; i++)
                sampler->MakeProposal();
        }
        ppv = particleGrid->m_NumParticles;
        particleGrid->ResetGrid();
    }
    delete sampler;
    delete encomp;
    delete particleGrid;
    delete interpolator;

    MITK_INFO << "GibbsTrackingFilter: finished estimating particle weight";
}
示例#5
0
  RJMCMCBase(float *points,int numPoints, float *dimg, const int *dsz, double *voxsize, double cellsize)
    : m_QBallImageData(dimg)
    , datasz(dsz)
    , enc(0)
    , width(dsz[1]*voxsize[0])
    , height(dsz[2]*voxsize[1])
    , depth(dsz[3]*voxsize[2])
    , voxsize(voxsize)
    , m_NumAttributes(0)
    , m_AcceptedProposals(0)
  {
    fprintf(stderr,"Data dimensions (mm) :  %f x %f x %f\n",width,height,depth);
    fprintf(stderr,"Data dimensions (voxel) :  %i x %i x %i\n",datasz[1],datasz[2],datasz[3]);
    fprintf(stderr,"voxel size (mm) :  %lf x %lf x %lf\n",voxsize[0],voxsize[1],voxsize[2]);

    float cellcnt_x = (int)((float)width/cellsize) +1;
    float cellcnt_y = (int)((float)height/cellsize) +1;
    float cellcnt_z = (int)((float)depth/cellsize) +1;
    //int cell_capacity = 2048;
    //int cell_capacity = 64;
    int cell_capacity = 512;

    fprintf(stderr,"grid dimensions :  %f x %f x %f\n",cellcnt_x,cellcnt_y,cellcnt_z);
    fprintf(stderr,"grid cell size (mm) :  %f^3\n",cellsize);
    fprintf(stderr,"cell capacity :  %i\n",cell_capacity);
    fprintf(stderr,"#cells*cellcap :  %.1f K\n",cell_capacity*cellcnt_x*cellcnt_y*cellcnt_z/1000);

    int minsize = 1000000;
    int err = m_ParticleGrid.allocate(((numPoints>minsize)? (numPoints+100000) : minsize), cellcnt_x, cellcnt_y, cellcnt_z, cellsize, cell_capacity);

    if (err == -1)
    {
      fprintf(stderr,"RJMCMCBase: out of Memory!\n");
      return;
    }

    m_NumAttributes = 10;
    for (int k = 0; k < numPoints; k++)
    {
      Particle *p = m_ParticleGrid.newParticle(pVector(points[m_NumAttributes*k], points[m_NumAttributes*k+1],points[m_NumAttributes*k+2]));
      if (p!=0)
      {
        p->N = pVector(points[m_NumAttributes*k+3],points[m_NumAttributes*k+4],points[m_NumAttributes*k+5]);
        p->cap =  points[m_NumAttributes*k+6];
        p->len =  points[m_NumAttributes*k+7];
        p->mID = (int) points[m_NumAttributes*k+8];
        p->pID = (int) points[m_NumAttributes*k+9];
        if (p->mID != -1)
          m_ParticleGrid.concnt++;
        if (p->pID != -1)
          m_ParticleGrid.concnt++;
        p->label = 0;
      }
      else
      {
        fprintf(stderr,"error: cannot allocate particle,  con. indices will be wrong! \n");
      }
    }
    m_ParticleGrid.concnt /= 2;

    m_Iterations = 0;
    m_AcceptedProposals = 0;
  }
示例#6
0
	RJMCMCBase(REAL *points,int numPoints, REAL *vfmap, REAL *dimg, const int *dsz, double *voxsize, double cellsize, REAL *cellsize2, REAL len, int numcores)
	{

		dataimg = dimg;
		datasz = dsz;
        this->vfmap = vfmap;
        
		width = datasz[2]*voxsize[0];
		height = datasz[3]*voxsize[1];   
		depth = datasz[4]*voxsize[2];

		this->voxsize = voxsize;
        this->numcores = numcores;

		fprintf(stderr,"Data dimensions (mm) :  %f x %f x %f\n",width,height,depth);
		fprintf(stderr,"Data dimensions (voxel) :  %i x %i x %i\n",datasz[2],datasz[3],datasz[4]);
		fprintf(stderr,"Data directions (sizeLUT * dirs) : %i * %i\n",datasz[0],datasz[1]);
		fprintf(stderr,"voxel size (mm) :  %f x %f x %f\n",voxsize[0],voxsize[1],voxsize[2]);
	

        ////// dimensions of the particle grid
        // the one to find connection partners
		REAL cellcnt_x = (int)((REAL)width/cellsize) +2;
		REAL cellcnt_y = (int)((REAL)height/cellsize) +2;
		REAL cellcnt_z = (int)((REAL)depth/cellsize) +2;
		int cell_capacity = 2048;
        // for finding partners whithn the same voxel
		REAL cellcnt_x2 = (int)((REAL)width/cellsize2[0]) +2;
		REAL cellcnt_y2 = (int)((REAL)height/cellsize2[1]) +2;
		REAL cellcnt_z2 = (int)((REAL)depth/cellsize2[2]) +2;
		int cell_capacity2 = 20; 

		fprintf(stderr,"grid dimensions :  %f x %f x %f\n",cellcnt_x,cellcnt_y,cellcnt_z);
		fprintf(stderr,"grid cell size (mm) :  %f^3\n",cellsize);
		fprintf(stderr,"grid2 dimensions :  %f x %f x %f\n",cellcnt_x2,cellcnt_y2,cellcnt_z2);
		fprintf(stderr,"grid2 cell size (mm) :  %fx%fx%f\n",cellsize2[0],cellsize2[1],cellsize2[2]);
    	fprintf(stderr,"cell capacity :  %i\n",cell_capacity);
    	fprintf(stderr,"#cells*cellcap :  %.1f K\n",cell_capacity*cellcnt_x*cellcnt_y*cellcnt_z/1000);
        #ifdef PARALLEL_OPENMP
		fprintf(stderr,"#threads :  %i/%i\n",numcores,omp_get_max_threads());
        #endif
        
        // allocate the particle grid
		int minsize = 100000;
		int err = pcontainer.allocate(((numPoints>minsize)? (numPoints+100000) : minsize), 
                cellcnt_x, cellcnt_y, cellcnt_z, cellsize,cell_capacity,
                cellcnt_x2, cellcnt_y2, cellcnt_z2, cellsize2,cell_capacity2,len);
        if (err == -1)
        {
            fprintf(stderr,"RJMCMCBase: out of Memory!\n");
            return;
        }
        
        // read the data from MATLAB into our structure
		attrcnt = 15;
		for (int k = 0; k < numPoints; k++)
			{
				Particle *p = pcontainer.newParticle(pVector(points[attrcnt*k  ], points[attrcnt*k+1],points[attrcnt*k+2]),
                                                     pVector(points[attrcnt*k+3], points[attrcnt*k+4],points[attrcnt*k+5]));
				if (p!=0) 
				{
					p->N = pVector(points[attrcnt*k+3],points[attrcnt*k+4],points[attrcnt*k+5]);				
					p->len =  points[attrcnt*k+7];	
					p->mID = (int) points[attrcnt*k+8];				
					p->pID = (int) points[attrcnt*k+9];	
					p->Di =  points[attrcnt*k+10];	
					p->Da =  points[attrcnt*k+11];	
					p->Dp =  points[attrcnt*k+12];	
					p->w =  points[attrcnt*k+13];	
					p->q =  points[attrcnt*k+14];	
                    p->label = 0;
                    p->active = true;
                    
					if (p->mID != -1)
                    {
                        pcontainer.removeFromGrid(1,p);
						pcontainer.concnt++;				
                    }
					if (p->pID != -1)
                    {
                        pcontainer.removeFromGrid(0,p);
						pcontainer.concnt++;		
                    }					
				}
				else
				{
					fprintf(stderr,"error: cannot allocate particle,  con. indices will be wrong! \n");
				}
			}
		pcontainer.concnt /= 2;
   


		itmax = 0;
        accepted = 0;

	}	
示例#7
0
    /////////////////////////////// the MAIN LOOP
	void iterate(double handle)
	{
		#ifdef TIMING
		tic(&total_time);
		#endif
                
        int frq = 500000;  // number iteration between MATLAB calls of 'drawnow'
        int numits;
        int outer = 0;
        REAL updownratio_break;
        
        bool adaptiveschedule = false;
        numits = (int) itmax;

        if (frq > numits)
        {
            frq = numits;
            outer = 1;
        }
        else
        {
            outer = numits/frq;
        }
        
        
        if (gammaDE != 0)  // then we have an adative temp-schedule
        {
            REAL itmax_d = gammaDE;
            stats.lam_deltaE = itmax_d;
            birthstats.lam_deltaE = itmax_d;
            deathstats.lam_deltaE = itmax_d;
            shiftstats.lam_deltaE = itmax_d;
            capstats.lam_deltaE = itmax_d;
            vfstats.lam_deltaE = itmax_d;
            connstats.lam_deltaE = itmax_d;
            
            adaptiveschedule = true;
        }
        else
        {
            adaptiveschedule = false;
        }
        
             
        #ifdef PARALLEL_OPENMP
        omp_set_dynamic(0);     // Explicitly disable dynamic teams
        omp_set_num_threads(numcores); // Use n threads for all consecutive parallel regions
        #endif
       
        #ifdef LINUX_MACHINE        
        static struct timeval timeS;
        #endif
        
        long time =0;
        
               
        
        int f;
		for (f = 0; f < outer;f++)
        {
            
            stats.clear();
            birthstats.clear();
            deathstats.clear();
            connstats.clear();
            shiftstats.clear();
            capstats.clear();
            vfstats.clear();
            //fprintf(stderr,"parain\n"); fflush(stderr);
            time = 0;
            #ifdef LINUX_MACHINE                  
            gettimeofday( &timeS, NULL);
            time -= (timeS.tv_sec*1000000 + timeS.tv_usec);
            #endif
            
            #ifdef PARALLEL_OPENMP
            #pragma omp parallel for 
            #endif
            for (int it = 0; it < frq;it++)
            {
                if (!pcontainer.needs_reallocation)
                    iterate_onestep();
            }            
            
            if (pcontainer.needs_reallocation)
            {
                if (pcontainer.reallocate() == -1)
                {
                    fprintf(stderr,"out of Memory!!\n");
                    return;
                }
            }
            
            #ifdef LINUX_MACHINE        
            gettimeofday( &timeS, NULL);
            time += (timeS.tv_sec*1000000 + timeS.tv_usec);	
            #endif
   
            fprintf(stderr,"#freeslots: %i  pcnt:%i  #particles:%i\n",
                    (int) pcontainer.freeslots.size(),(int) pcontainer.pcnt,(int)(pcontainer.pcnt-pcontainer.freeslots.size()));
            pcontainer.defrag();

            fprintf(stderr,"#it: %ik  #p: %i #c: %i time: %.2fs  \n",  frq*(f+1)/1000, pcontainer.pcnt,pcontainer.concnt,double(time)/1000000);
            stats.report_movetype(" total:");
            
            char buf[256];
            sprintf(buf,"birth (%.3f):",p_birth);
            birthstats.report_movetype(buf);
            sprintf(buf,"death (%.3f):",p_death);
            deathstats.report_movetype(buf);
            sprintf(buf,"shift (%.3f):",p_shift);
            shiftstats.report_movetype(buf);
            sprintf(buf,"model (%.3f):",p_Dmod);
            capstats.report_movetype(buf);
            sprintf(buf,"volfr (%.3f):",p_vfmod);
            vfstats.report_movetype(buf);
            sprintf(buf,"track (%.3f):",p_conprob);
            connstats.report_movetype(buf);

            
            REAL cr = (REAL) pcontainer.celloverflows;
            if (cr > 0.01)
                fprintf(stderr,"warning: celloverflows : %.2f \n",cr);
            if (handle != 0)
            {
                mexEvalString("drawnow");
                if (mexGet(handle,"Tag") == 0)
                {
                    fprintf(stderr,"Termination by User.\n\n");
                	break;
                }
            }
            accepted = 0;

            
            if (adaptiveschedule && stats.deltaE < 0)
            {
                fprintf(stderr,"equilibrium threshold reached, breaking\n");
                break;
            }
            

        }
            
        iterations_done = (f+1)*frq; //it;

	}