C++ Volume::dimension方法代码示例

int main(int argc, char **argv)
{
  if(argc != 3)
    {
      cerr << "Usage: " << argv[0] << " <input volume file> <output volume file>" << endl;
      return 1;
    }

  try
    {
      VolMagickOpStatus status;
      VolMagick::setDefaultMessenger(&status);

      VolMagick::VolumeFileInfo volinfo;

      volinfo.read(argv[1]);

      VolMagick::createVolumeFile(argv[2],
				  volinfo.boundingBox(),
				  volinfo.dimension(),
				  volinfo.voxelTypes(),
				  volinfo.numVariables(),
				  volinfo.numTimesteps(),
				  volinfo.TMin(),volinfo.TMax());

      for(unsigned int var=0; var<volinfo.numVariables(); var++)
	for(unsigned int time=0; time<volinfo.numTimesteps(); time++)
	  {
	    VolMagick::Volume vol;
	    readVolumeFile(vol,argv[1],var,time);
	    for(VolMagick::uint64 i = 0; i < vol.dimension().size(); i++)
	      vol(i, vol.min() + ((vol.max() - vol(i))/(vol.max() - vol.min()))*(vol.max() - vol.min()));
	    vol.desc(volinfo.name(var));
	    writeVolumeFile(vol,argv[2],var,time);
	  }
    }
  catch(VolMagick::Exception &e)
    {
      cerr << e.what() << endl;
    }
  catch(std::exception &e)
    {
      cerr << e.what() << endl;
    }

  return 0;
}

int main(int argc, char **argv)
{
  if(argc < 4)
    {
      std:: cerr << "make templete volume with initial value:" << std::endl;
      std:: cerr << "Usage: " << argv[0] << "<ref. vol> <set val(float)> <out vol>" << std::endl;
      return 1;
    }

  try
    {
      VolMagick::Volume outputVol;

      VolMagick::VolumeFileInfo volinfo;
      volinfo.read(argv[1]);

      float setval = atof( argv[2] );

      outputVol.voxelType(volinfo.voxelType());
      outputVol.dimension(volinfo.dimension());
      outputVol.boundingBox(volinfo.boundingBox());
   
      int dimx = outputVol.XDim();
      int dimy = outputVol.YDim();
      int dimz = outputVol.ZDim();
      fprintf( stderr, "dim: %d %d %d\n", dimx, dimy, dimz );

      for( int kz = 0; kz<dimz; kz++)
        for( int jy = 0; jy<dimy; jy++)
          for( int ix = 0; ix<dimx; ix++)
 	    outputVol(ix,jy,kz, setval);
      
      VolMagick::createVolumeFile(outputVol, argv[argc-1]);

    }

  catch(VolMagick::Exception &e)
    {
      std:: cerr << e.what() << std::endl;
    }
  catch(std::exception &e)
    {
      std::cerr << e.what() << std::endl;
    }

  return 0;
}

int main(int argc, char **argv)
{
  if(argc < 3)
    {
      std:: cerr << 
	"Usage: " << argv[0] << 
"First argument is the mask volume (128), second argument is the input intensity map, third argument is the outputfile\n";
	

      return 1;
    }

  try
    {
      VolMagick::Volume inputVol;

      VolMagick::Volume inputVol2;
      
      VolMagick::Volume outputVol;

      VolMagick::readVolumeFile(inputVol,argv[1]); ///first argument is mask volume
      
      VolMagick::readVolumeFile(inputVol2, argv[2]); /// second argument is input volume
      

      VolMagick::VolumeFileInfo volinfo1;
      volinfo1.read(argv[1]);
      std::cout << volinfo1.filename() << ":" <<std::endl;

      VolMagick::VolumeFileInfo volinfo2;
      volinfo2.read(argv[2]);
      std::cout << volinfo2.filename() << ":" <<std::endl;
      
      std::cout<<"minVol1 , maxVol1: "<<volinfo1.min()<<" "<<volinfo1.max()<<std::endl;;

      std::cout<<"minVol2 , maxVol2: "<<volinfo2.min()<<" "<<volinfo2.max()<<std::endl;

      
      
      outputVol.voxelType(inputVol.voxelType());
      outputVol.dimension(inputVol.dimension());
      outputVol.boundingBox(inputVol.boundingBox());
      
      
      std::cout<<"voxeltype "<<inputVol.voxelType()<<std::endl;
      	
	if(volinfo1.max()!=0)
		float inputVol1Scaling = volinfo1.min()/volinfo1.max();
	
	if(volinfo2.max()!=0)
		float inputVol2Scaling = volinfo2.min()/volinfo2.max();
      
      
      for( int kz = 0; kz<inputVol.ZDim(); kz++)
	{
	//  std::cout<<kz<<"..";
	    for( int jy = 0; jy<inputVol.YDim(); jy++)
	      for( int ix = 0; ix<inputVol.XDim(); ix++)
		{
		
		outputVol(ix,jy,kz, 0);

               if(inputVol(ix,jy,kz))
//                outputVol(ix,jy, kz, inputVol2(ix,jy,kz));
		outputVol(ix,jy,kz, inputVol2(ix,jy,kz));

		
		  
		}
	}	
      std::cout<<"done !" <<std::endl;

      VolMagick::createVolumeFile(outputVol, argv[argc-1]);





    }

  catch(VolMagick::Exception &e)
    {
      std:: cerr << e.what() << std::endl;
    }
  catch(std::exception &e)
    {
      std::cerr << e.what() << std::endl;
    }

  return 0;
}

/*using namespace std;

class VolMagickOpStatus : public VolMagick::VoxelOperationStatusMessenger
{
public:
  void start(const VolMagick::Voxels *vox, Operation op, VolMagick::uint64 numSteps) const
  {
    _numSteps = numSteps;
  }

  void step(const VolMagick::Voxels *vox, Operation op, VolMagick::uint64 curStep) const
  {
    const char *opStrings[] = { "CalculatingMinMax", "CalculatingMin", "CalculatingMax",
				"SubvolumeExtraction", "Fill", "Map", "Resize", "Composite",
				"BilateralFilter", "ContrastEnhancement"};

    fprintf(stderr,"%s: %5.2f %%\r",opStrings[op],(((float)curStep)/((float)((int)(_numSteps-1))))*100.0);
  }

  void end(const VolMagick::Voxels *vox, Operation op) const
  {
    printf("\n");
  }

private:
  mutable VolMagick::uint64 _numSteps;
};

typedef boost::tuple<double, double, double> Color;
*/
int main(int argc, char **argv)
{
  if(argc < 3)
    {
      std:: cerr << 
	"Usage: " << argv[0] << "[vol 1] [vol 2] [out vol] [threshold]";
      std:: cerr <<
	"first volume + second volume = output volume. The voxels are remapped giving two different intensity ranges for the volumes, and threshold will be used for the second volume if it was set \n";

      return 1;
    }

  try
    {
      VolMagick::Volume inputVol;

      VolMagick::Volume inputVol2;
      
      VolMagick::Volume outputVol;

      VolMagick::readVolumeFile(inputVol,argv[1]); ///first argument is input volume
      
      VolMagick::readVolumeFile(inputVol2, argv[2]); /// second argument is mask volume
      

      VolMagick::VolumeFileInfo volinfo1;
      volinfo1.read(argv[1]);
      std::cout << volinfo1.filename() << ":" <<std::endl;

      VolMagick::VolumeFileInfo volinfo2;
      volinfo2.read(argv[2]);
      std::cout << volinfo2.filename() << ":" <<std::endl;
      
      std::cout<<"minVol1 , maxVol1: "<<volinfo1.min()<<" "<<volinfo1.max()<<std::endl;;

      std::cout<<"minVol2 , maxVol2: "<<volinfo2.min()<<" "<<volinfo2.max()<<std::endl;

      
      double thold = 0.0001;
      if( argc > 3) thold = atof( argv[4] );
      if( thold < 0.0001 ) thold = 0.0001;

      outputVol.voxelType(inputVol.voxelType());
      outputVol.dimension(inputVol.dimension());
      outputVol.boundingBox(inputVol.boundingBox());
      
      
      std::cout<<"voxeltype "<<inputVol.voxelType()<<std::endl;
      double min1 = volinfo1.min(); 
      double range1 = volinfo1.max()-volinfo1.min(); 
      double min2 = volinfo2.min(); 
      double range2 = volinfo2.max()-volinfo2.min(); 
      
      for( int kz = 0; kz<inputVol.ZDim(); kz++)
	{
	  std::cout<<kz<<"..";
	    for( int jy = 0; jy<inputVol.YDim(); jy++)
	      for( int ix = 0; ix<inputVol.XDim(); ix++)
		{
		  
		  outputVol(ix,jy,kz, 0);
		  
		  if( (inputVol(ix,jy,kz)- min1 ) > 0.0001 )
		    
		    outputVol(ix,jy,kz, ( (inputVol(ix,jy,kz)-min1)/range1)*128.0 );
		  
		  if( (inputVol2(ix,jy,kz)-min2) > thold)
		    
		    outputVol(ix,jy,kz, ( (inputVol2(ix,jy,kz)-min2)/range2)*128.0 + 128.0);
		  
//.........这里部分代码省略.........

/*using namespace std;

class VolMagickOpStatus : public VolMagick::VoxelOperationStatusMessenger
{
public:
  void start(const VolMagick::Voxels *vox, Operation op, VolMagick::uint64 numSteps) const
  {
    _numSteps = numSteps;
  }

  void step(const VolMagick::Voxels *vox, Operation op, VolMagick::uint64 curStep) const
  {
    const char *opStrings[] = { "CalculatingMinMax", "CalculatingMin", "CalculatingMax",
				"SubvolumeExtraction", "Fill", "Map", "Resize", "Composite",
				"BilateralFilter", "ContrastEnhancement"};

    fprintf(stderr,"%s: %5.2f %%\r",opStrings[op],(((float)curStep)/((float)((int)(_numSteps-1))))*100.0);
  }

  void end(const VolMagick::Voxels *vox, Operation op) const
  {
    printf("\n");
  }

private:
  mutable VolMagick::uint64 _numSteps;
};

typedef boost::tuple<double, double, double> Color;
*/
int main(int argc, char **argv)
{
  if(argc < 3)
    {
      std:: cerr << 
	"Usage: " << argv[0] << "[vol 1] [vol 2...] [out vol]";
      std:: cerr <<
	"vol1 + vol2 + .. + voln = output volume. The voxels are remapped giving n different intensity ranges for the volumes, <0~256/n, 0~2*256/n, ..., 0~256>, for example.\n";

      return 1;
    }

  try
    {
      int nInVols = argc - 2;
      VolMagick::Volume *inVols = new VolMagick::Volume[ nInVols ];
      double *minvols = new double[ nInVols ];
      double *ranges = new double[ nInVols ];
      double volrangeunit = 256.0 / (double)nInVols;

      // read volumes and compute min & range
      for( int i = 0; i < nInVols; i++ ) {
         VolMagick::readVolumeFile( inVols[i], argv[i+1] );
         minvols[i] = inVols[i].min();
         ranges[i] = inVols[i].max() - inVols[i].min();
         std::cout<< "volume " << i << ": min, max: "<<minvols[i]<<" "<<inVols[i].max()<<std::endl;
         std::cout<< "volume " << i << ": dim: "<<inVols[i].XDim()<<" "<<inVols[i].YDim()<<" "<<inVols[i].ZDim()<<std::endl;
      }
      double thold = 0.0001;

      VolMagick::Volume outputVol;
      outputVol.voxelType(inVols[0].voxelType());
      outputVol.dimension(inVols[0].dimension());
      outputVol.boundingBox(inVols[0].boundingBox());
     
      int dimx = inVols[0].XDim();
      int dimy = inVols[0].YDim();
      int dimz = inVols[0].ZDim();
 
      for( int kz = 0; kz<dimz; kz++)
	{
	  std::cout<<kz<<"..";
	    for( int jy = 0; jy<dimy; jy++)
	      for( int ix = 0; ix<dimx; ix++)
		{
		  
		  outputVol(ix,jy,kz, 0);
	
                  for( int i = 0; i < nInVols; i++ )
	   	     if( (inVols[i](ix,jy,kz)- minvols[i] ) > thold )
		        outputVol(ix,jy,kz, ( (inVols[i](ix,jy,kz)-minvols[i])/ranges[i])*((i+1)*volrangeunit) );
		}
	}	
     
      VolMagick::createVolumeFile(outputVol, argv[argc-1]);

    }

  catch(VolMagick::Exception &e)
    {
      std:: cerr << e.what() << std::endl;
    }
  catch(std::exception &e)
    {
      std::cerr << e.what() << std::endl;
    }

  return 0;
}

int main(int argc, char **argv)
{
  if(argc < 4)
    {
      std:: cerr << 
	"Usage: " << argv[0] << 
	"  first volume - second volume, output volume, threshold " << std::endl;
	      return 1;
    }

  try
    {
      VolMagick::Volume inputVol;

      VolMagick::Volume inputVol2;
      
      VolMagick::Volume outputVol;

      VolMagick::readVolumeFile(inputVol,argv[1]); ///first argument is input volume
      
      VolMagick::readVolumeFile(inputVol2, argv[2]); /// second argument is mask volume
      
	  float threshold = atof(argv[4]);

      VolMagick::VolumeFileInfo volinfo1;
      volinfo1.read(argv[1]);
      std::cout << volinfo1.filename() << ":" <<std::endl;

      VolMagick::VolumeFileInfo volinfo2;
      volinfo2.read(argv[2]);

      std::cout << volinfo2.filename() << ":" <<std::endl;
      
      std::cout<<"minVol1 , maxVol1: "<<volinfo1.min()<<" "<<volinfo1.max()<<std::endl;;

      std::cout<<"minVol2 , maxVol2: "<<volinfo2.min()<<" "<<volinfo2.max()<<std::endl;

      
      
      outputVol.voxelType(inputVol.voxelType());
      outputVol.dimension(inputVol.dimension());
      outputVol.boundingBox(inputVol.boundingBox());
      
      
      std::cout<<"voxeltype "<<inputVol.voxelType()<<std::endl;
      	
	 // int step = 1;
   //   if(argc==5) step= atoi(argv[argc-1]);

	  outputVol= inputVol;

      
      for( int kz = 0; kz<inputVol2.ZDim(); kz++)
	{
	    for( int jy = 0; jy<inputVol2.YDim(); jy++)
	      for( int ix = 0; ix<inputVol2.XDim(); ix++)
		{
	//	  if(inputVol2(ix, jy, kz)<= inputVol(ix, jy, kz)) 
	//	  {
		     outputVol(ix, jy, kz, inputVol(ix,jy,kz)-inputVol2(ix,jy,kz));
					
	//	  }
	//	  else outputVol(ix,jy,kz, inputVol.min());
			  
		}
	}	
      

      VolMagick::createVolumeFile(outputVol, argv[3]);





    }

  catch(VolMagick::Exception &e)
    {
      std:: cerr << e.what() << std::endl;
    }
  catch(std::exception &e)
    {
      std::cerr << e.what() << std::endl;
    }

  return 0;
}

int main(int argc, char **argv)
{
    if(argc < 3)
    {
        std:: cerr <<
                   "Usage: " << argv[0] <<


                   "  <first volume>  <output volume>.   \n";

        return 1;
    }

    try
    {
        VolMagick::Volume inputVol;


        VolMagick::Volume outputVol;

        VolMagick::readVolumeFile(inputVol,argv[1]); ///first argument is input volume

        VolMagick::VolumeFileInfo volinfo1;
        volinfo1.read(argv[1]);
        std::cout << volinfo1.filename() << ":" <<std::endl;


        std::cout<<"minVol1 , maxVol1: "<<volinfo1.min()<<" "<<volinfo1.max()<<std::endl;;


        VolMagick::BoundingBox bbox;
        bbox.minx = inputVol.XMin();
        bbox.maxx = inputVol.XMax();
        bbox.miny = inputVol.YMin();
        bbox.maxy = inputVol.YMax();
        bbox.minz = 2.0*inputVol.ZMin() - inputVol.ZMax();
        bbox.maxz = inputVol.ZMax();

        VolMagick::Dimension dim;
        dim.xdim = inputVol.XDim();
        dim.ydim = inputVol.YDim();
        dim.zdim = (int)((bbox.maxz -bbox.minz)/inputVol.ZSpan())+1;


//	 cout<<bbox.minz <<" " << bbox.maxz<<" "<< bbox.maxy <<endl;
//	 cout<<dim.zdim <<" " << dim.ydim << endl;

        outputVol.voxelType(inputVol.voxelType());
        outputVol.dimension(dim);
        outputVol.boundingBox(bbox);





        for( int kz = 0; kz<outputVol.ZDim()/2; kz++)
            for( int jy = 0; jy<inputVol.YDim(); jy++)
                for( int ix = 0; ix<inputVol.XDim(); ix++)
                    outputVol(ix, jy, kz, inputVol(inputVol.XDim()-1-ix, inputVol.YDim()-1-jy, inputVol.ZDim()-1-kz));

        for( int kz=outputVol.ZDim()/2; kz < outputVol.ZDim(); kz++)
            for( int jy = 0; jy<inputVol.YDim(); jy++)
                for( int ix = 0; ix<inputVol.XDim(); ix++)
                    outputVol(ix, jy, kz, inputVol(ix, jy, kz+1-inputVol.ZDim()));








        VolMagick::createVolumeFile(outputVol, argv[2]);


        cout<<"done!"<<endl;

    }

    catch(VolMagick::Exception &e)
    {
        std:: cerr << e.what() << std::endl;
    }
    catch(std::exception &e)
    {
        std::cerr << e.what() << std::endl;
    }

    return 0;
}

int main(int argc, char **argv) {
  // Initialize log4cplus
  std::ifstream testfile("log4cplus.properties");
  if (testfile) {
    testfile.close();
    log4cplus::PropertyConfigurator::doConfigure("log4cplus.properties");
  }
  else {
    log4cplus::BasicConfigurator::doConfigure();
  }

  if(argc < 9) {
    std::cerr << "Usage: " << argv[0] << " <first volume>" <<
	"<xmin> <ymin> <zmin> <xmax> <ymax> <zmax>  <output volume> \n";
    return 1;
  }

  try {
    VolMagick::Volume inputVol;
    VolMagick::readVolumeFile(inputVol,argv[1]); ///first argument is input volume
	
    VolMagick::Volume  outputVol;
	
    VolMagick::VolumeFileInfo volinfo1;
    volinfo1.read(argv[1]);
    std::cout << volinfo1.filename() << ":" <<std::endl;

    std::cout << "minVol1 , maxVol1: " << volinfo1.min() << " " << 
        volinfo1.max() << std::endl;;
 
    float span[3];
    span[0]=inputVol.XSpan(); 
    span[1]=inputVol.YSpan(); 
    span[2]=inputVol.ZSpan();
	
    VolMagick::BoundingBox bbox;
    bbox.minx = atof(argv[2]);
    bbox.miny = atof(argv[3]);
    bbox.minz = atof(argv[4]);
    bbox.maxx = atof(argv[5]);
    bbox.maxy = atof(argv[6]);
    bbox.maxz = atof(argv[7]);
	
    VolMagick::Dimension dim;
    dim.xdim = (int) ((bbox.maxx-bbox.minx)/ span[0])+1;
    dim.ydim = (int) ((bbox.maxy-bbox.miny)/ span[1])+1;
    dim.zdim = (int) ((bbox.maxz-bbox.minz)/ span[2])+1;

    bbox.maxx = bbox.minx + (dim.xdim-1)*span[0];
    bbox.maxy = bbox.miny + (dim.ydim-1)*span[1];
    bbox.maxz = bbox.minz + (dim.zdim-1)*span[2];
 	
    outputVol.voxelType(inputVol.voxelType());
    outputVol.dimension(dim);
    outputVol.boundingBox(bbox);
      
    float temp;
    int i, j, k;
    int xsh = (int)((bbox.minx - inputVol.XMin())/span[0]);
    int ysh = (int)((bbox.miny - inputVol.YMin())/span[1]);
    int zsh = (int)((bbox.minz - inputVol.ZMin())/span[2]);

    for( int kz = 0; kz<outputVol.ZDim(); kz++) {
      for( int jy = 0; jy<outputVol.YDim(); jy++) {
        for( int ix = 0; ix<outputVol.XDim(); ix++) {
          i = ix + xsh;
          j = jy + ysh;
          k = kz + zsh;
          if (i<0 || i >= inputVol.XDim()|| j<0 || j>= inputVol.YDim() || k <0 || k>=inputVol.ZDim()) {
            outputVol(ix, jy, kz, 0.0);
          } else {
            outputVol(ix,jy,kz, inputVol(i,j,k));
          }
        }
      }
    }
    std::cout << "creating volume file..." << std::endl;
    VolMagick::createVolumeFile(outputVol, argv[8]);
    std::cout << "done!" << std::endl;
  } catch(VolMagick::Exception &e) {
    std:: cerr << e.what() << std::endl;
  } catch(std::exception &e) {
    std::cerr << e.what() << std::endl;
  }

  return 0;
}

int main(int argc, char **argv)
{
  if(argc < 3)
    {
      std:: cerr << 
	"Usage: " << argv[0] << 

	
	"<first volume>  <second volume> <output volume> <int Interpolate number> \n";

      return 1;
    }

  try
    {
      VolMagick::Volume inputVol;

      VolMagick::Volume inputVol2;

      
      
      VolMagick::readVolumeFile(inputVol,argv[1]); ///first argument is input volume
      
      VolMagick::readVolumeFile(inputVol2, argv[2]); /// second argument is mask volume
      
	  int number = atoi(argv[4]);
	
	  VolMagick::Volume  outputVol;

	
      VolMagick::VolumeFileInfo volinfo1;
      volinfo1.read(argv[1]);
      std::cout << volinfo1.filename() << ":" <<std::endl;

      VolMagick::VolumeFileInfo volinfo2;
      volinfo2.read(argv[2]);
      std::cout << volinfo2.filename() << ":" <<std::endl;
      
      std::cout<<"minVol1 , maxVol1: "<<volinfo1.min()<<" "<<volinfo1.max()<<std::endl;;

      std::cout<<"minVol2 , maxVol2: "<<volinfo2.min()<<" "<<volinfo2.max()<<std::endl;

      
      outputVol.voxelType(inputVol.voxelType());
      outputVol.dimension(inputVol.dimension());
      outputVol.boundingBox(inputVol.boundingBox());
      
      

      
      
	for (int num = 1; num < number; num ++)
    {
	  std::cout<<"\xd"<<(float)(num)/(float)(number-1)*100.00<<"% is finished";
	  for( int kz = 0; kz<inputVol.ZDim(); kz++)
	   for( int jy = 0; jy<inputVol.YDim(); jy++)
	     for( int ix = 0; ix<inputVol.XDim(); ix++)
		  	outputVol(ix,jy,kz, (inputVol(ix,jy,kz)*(1.0-(float)(num/(float)(number-1))) + inputVol2(ix,jy,kz))*(float)(num/(float)(number-1))  );
			stringstream s;
	 		s<<argv[3]<< num <<".rawiv";
	      VolMagick::createVolumeFile(outputVol, s.str());
    }

    std::cout<<"done!"<<std::endl;


    }

  catch(VolMagick::Exception &e)
    {
      std:: cerr << e.what() << std::endl;
    }
  catch(std::exception &e)
    {
      std::cerr << e.what() << std::endl;
    }

  return 0;
}

int main(int argc, char **argv)
{
  if(argc < 5)
    {
      std:: cerr << 
	"Usage: " << argv[0] <<"  inputfile   t_low   t_high   outputFile \n";
      return 1;
    }

  try
    {
      VolMagick::Volume inputVol;

      VolMagick::Volume inputVol2;
      
      VolMagick::Volume outputVol;

      VolMagick::readVolumeFile(inputVol,argv[1]); ///first argument is input volume
      
      

      VolMagick::VolumeFileInfo volinfo1;
      volinfo1.read(argv[1]);
      std::cout << volinfo1.filename() << ":" <<std::endl;

      
      outputVol.voxelType(inputVol.voxelType());
      outputVol.dimension(inputVol.dimension());
      outputVol.boundingBox(inputVol.boundingBox());
      
      
      std::cout<<"voxeltype "<<inputVol.voxelType()<<std::endl;
      	
     float tlow = atof(argv[2]);
     float thigh = atof(argv[3]); 
     
	 if(tlow < 0)
	 {
	 	tlow = 0;
		std::cout<<"tlow should be bigger than 0, set to 0. "<<std::endl;
	}
	 if(thigh>255) 
	 {
	 	thigh = 255;
		std::cout<<"thigh should be smaller than 255, set to 255. " <<std::endl;
	 }

      for( int kz = 0; kz<inputVol.ZDim(); kz++)
	 {
	    for( int jy = 0; jy<inputVol.YDim(); jy++)
	      for( int ix = 0; ix<inputVol.XDim(); ix++)
		{
		  float temp = inputVol(ix, jy, kz);
		  float temp1 = 255.0*(temp-volinfo1.min())/(volinfo1.max()-volinfo1.min());
		  if( (temp1 >= tlow) && (temp1 < thigh))
		  	outputVol(ix, jy, kz, temp);
		  else outputVol(ix, jy, kz, volinfo1.min());

		}
	}	
      

      VolMagick::createVolumeFile(outputVol, argv[argc-1]);


	std::cout<<" done!" <<std::endl;


    }

  catch(VolMagick::Exception &e)
    {
      std:: cerr << e.what() << std::endl;
    }
  catch(std::exception &e)
    {
      std::cerr << e.what() << std::endl;
    }

  return 0;
}

int main(int argc, char **argv)
{
  if(argc<4)
    {
      cerr <<
 
	"Usage: inputfile, projectionAngles, outputfile" << endl;


      return 1;
    }


  try
    {    
      typedef boost::int64_t int64_t;

      VolMagick::Volume inputVol;

      VolMagick::Volume outputVol;   

      VolMagick::Volume startPtVol;

     VolMagick::Volume endPtVol;

      VolMagick::Volume rotatedVol;

      VolMagick::readVolumeFile(inputVol,argv[1]); ///first argument is input volume
    
      
	 
      static double PI = 3.14159265;
 
      std::cout<<"vol read\n";



       int numProcs = omp_get_num_procs();
      std::cout<<"Num of processors: "<< numProcs<<"\n";

      int64_t numAngles = 0;
	
      FILE* fp = fopen(argv[2],"r");
     
      std::cout<<"Counting angles \n";
	
      float tmp;	
	

	while(fscanf(fp, "%f", &tmp) != EOF)
		numAngles++;

	fclose(fp);


   // initialize projection output volume

//	 outputVol.dimension(VolMagick::Dimension(inputVol.XDim(), inputVol.YDim(), numAngles));

	 VolMagick::Dimension dim;

	 dim.xdim = inputVol.XDim();

	 dim.ydim = inputVol.YDim();

	 dim.zdim = numAngles;
	
	 VolMagick::VoxelType vox = VolMagick::Float;

	 outputVol.voxelType(vox);

         VolMagick::BoundingBox outputBB;

	 outputBB.minx = inputVol.boundingBox().minx;

	 outputBB.maxx = inputVol.boundingBox().maxx;
	 
	 outputBB.maxy = inputVol.boundingBox().maxy;	

	 outputBB.miny = inputVol.boundingBox().miny;

	 outputBB.minz = 0;

	 outputBB.maxz = numAngles-1;

	 outputVol.boundingBox(outputBB);

	 outputVol.dimension(dim);
	
		
	// check
	std::cout<<outputVol.XDim()<<" "<<outputVol.YDim()<<" "<<outputVol.ZDim()<<"\n";
	
	std::cout<<outputVol.boundingBox().maxx<<" "<<outputVol.boundingBox().maxy<<" "<<outputVol.boundingBox().maxz<<"\n";

	std::cout<<outputVol.boundingBox().minx<<" "<<outputVol.boundingBox().miny<<" "<<outputVol.boundingBox().minz<<"\n";

	std::cout<<outputVol.voxelType()<<"\n";
	
//	
//.........这里部分代码省略.........

int main(int argc, char **argv)
{
  if(argc < 4)
    {
      std:: cerr << 
	"Usage: " << argv[0] << 

	
	"<input vol 1> <input vol 2> <output vol> \n";

      return 1;
    }

  try
    {
      VolMagick::Volume inputVol;

      VolMagick::Volume inputVol2;
      
      VolMagick::Volume outputVol;

      VolMagick::VolumeFileInfo volinfo;
      volinfo.read(argv[1]);


      VolMagick::readVolumeFile(inputVol,argv[1]); ///first argument is input volume
      
      VolMagick::readVolumeFile(inputVol2, argv[2]); /// second argument is mask volume
      

      VolMagick::VolumeFileInfo volinfo1;
      volinfo1.read(argv[1]);
      std::cout << volinfo1.filename() << ":" <<std::endl;

      VolMagick::VolumeFileInfo volinfo2;
      volinfo2.read(argv[2]);
      std::cout << volinfo2.filename() << ":" <<std::endl;
      
      std::cout<<"minVol1 , maxVol1: "<<volinfo1.min()<<" "<<volinfo1.max()<<std::endl;;

      std::cout<<"minVol2 , maxVol2: "<<volinfo2.min()<<" "<<volinfo2.max()<<std::endl;

           

      outputVol.voxelType(inputVol.voxelType());
      outputVol.dimension(inputVol.dimension());
      outputVol.boundingBox(inputVol.boundingBox());
      
      
      std::cout<<"voxeltype "<<inputVol.voxelType()<<std::endl;
      

      double min=100000000.0;
      double max=-100000000.0;
      
      for( int kz = 0; kz<inputVol.ZDim(); kz++)
	{
	  std::cout<<kz<<"..";
	    for( int jy = 0; jy<inputVol.YDim(); jy++)
	      for( int ix = 0; ix<inputVol.XDim(); ix++)
		{		  
		  outputVol(ix,jy,kz, inputVol(ix,jy,kz)+inputVol2(ix,jy,kz));

		  if (inputVol(ix,jy,kz)+inputVol2(ix,jy,kz) < min) {
		    min = inputVol(ix,jy,kz)+inputVol2(ix,jy,kz);
		  }

		  if (inputVol(ix,jy,kz)+inputVol2(ix,jy,kz) >max) {
		    max = inputVol(ix,jy,kz)+inputVol2(ix,jy,kz);
		  }



		}
	}	
      

      std::cout << std::endl << "New Min/Max " << min << " " << max << std::endl;

      VolMagick::createVolumeFile(argv[3],volinfo);

      VolMagick::writeVolumeFile(outputVol, argv[3]);

    }

  catch(VolMagick::Exception &e)
    {
      std:: cerr << e.what() << std::endl;
    }
  catch(std::exception &e)
    {
      std::cerr << e.what() << std::endl;
    }

  return 0;
}

int main(int argc, char **argv)
{
  VolMagick::uint64 width, height, depth, i, j, k;
  Image cur;
  unsigned char *buf;

  if(argc < 3)
    {
      cout << "Usage: " << argv[0] << " <img0> <img1> ... <output volume>" << endl;
      return 0;
    }

  try
    {
#if 0
      // get width and height.  All images should have the same width and height
      // or this program will explode!!!!
      cur.read(argv[1]);
      width = cur.size().width();
      height = cur.size().height();

      cerr << "Image dimensions: " << width << ", " << height << endl;

      // get the depth
      depth = argc-2;
      cerr << "Volume dimensions: " << width << ", " << height << ", " << depth << endl;

      // allocate the slice buffer and open the volume file
      buf = (unsigned char *)malloc(width*height*sizeof(unsigned char));
      outvol = fopen(argv[argc-1],"wb");
      if(outvol == NULL)
	{
	  cerr << "Unable to open output file '" << argv[argc-1] << "'" << endl;
	  return 1;
	}

      // fill out the header and write it
      header.min[0] = 0.0; header.min[1] = 0.0; header.min[2] = 0.0;
      header.max[0] = float(width-1); header.max[1] = float(height-1); header.max[2] = float(depth-1);
      header.numVerts = width * height * depth;
      header.numCells = (width-1)*(height-1)*(depth-1);
      header.dim[0] = width; header.dim[1] = height; header.dim[2] = depth;
      header.origin[0] = header.origin[1] = header.origin[2] = 0.0;
      header.span[0] = 1.0; header.span[1] = 1.0; header.span[2] = 1.0;

      if(!big_endian())
	{
	  for(i=0; i<3; i++) SWAP_32(&(header.min[i]));
	  for(i=0; i<3; i++) SWAP_32(&(header.max[i]));
	  SWAP_32(&(header.numVerts));
	  SWAP_32(&(header.numCells));
	  for(i=0; i<3; i++) SWAP_32(&(header.dim[i]));
	  for(i=0; i<3; i++) SWAP_32(&(header.origin[i]));
	  for(i=0; i<3; i++) SWAP_32(&(header.span[i]));
	}

      fwrite(&header,sizeof(RawIVHeader),1,outvol);

      //now write out each image slice
      for(k=0; k<depth; k++)
	{
	  cur.read(Geometry(width,height),argv[k+1]);
	  cur.modifyImage();
	  cur.type(GrayscaleType);
	  /*
	   * We only need 1 value since after grayscale conversion R = G = B
	   */
	  cur.write(0,0,width,height,"R",CharPixel,buf);

	  /*
	    const PixelPacket *pixel_cache = cur.getConstPixels(0,0,width,height);
	    for(i=0; i<width; i++)
	    for(j=0; j<height; j++)
	    {
	    const PixelPacket *pixel = pixel_cache+j*width+i;
	    if(pixel  == NULL) cout << "i: " << i << ", j: " << j << endl;
	    ColorRGB c(*pixel);
	    buf[j*width+i] = (unsigned char)(c.green()*255.0);
	    }
	  */

	  fwrite(buf,sizeof(unsigned char),width*height,outvol);
	}

      free(buf);
      fclose(outvol);
#endif

      // get width and height.  All images should have the same width and height
      // or this program will explode!!!!
      cur.read(argv[1]);
      width = cur.size().width();
      height = cur.size().height();

      // get the depth
      depth = argc-2;
      cerr << "Volume dimensions: " << width << ", " << height << ", " << depth << endl;

      VolMagick::createVolumeFile(argv[argc-1],
				  VolMagick::BoundingBox(0.0,0.0,0.0,
//.........这里部分代码省略.........

int main(int argc, char **argv)
{
  if(argc < 6)
    {
      std:: cerr << 
	"Usage: " << argv[0] << 

	
	" <first volume>  <xmin> <ymin> <zmin> <output volume> \n";

      return 1;
    }

  try
    {
      VolMagick::Volume inputVol;


      
      
      VolMagick::readVolumeFile(inputVol,argv[1]); ///first argument is input volume
      
	
	  VolMagick::Volume  outputVol;

	
      VolMagick::VolumeFileInfo volinfo1;
      volinfo1.read(argv[1]);
      std::cout << volinfo1.filename() << ":" <<std::endl;

      
      std::cout<<"minVol1 , maxVol1: "<<volinfo1.min()<<" "<<volinfo1.max()<<std::endl;;
 
	  float span[3];
	  span[0]=inputVol.XSpan(); 
	  span[1]=inputVol.YSpan(); 
	  span[2]=inputVol.ZSpan();
	
	  VolMagick::BoundingBox bbox;
	  bbox.minx = atof(argv[2]);
	  bbox.miny = atof(argv[3]);
	  bbox.minz = atof(argv[4]);
	  bbox.maxx = bbox.minx + volinfo1.XMax()-volinfo1.XMin();
	  bbox.maxy = bbox.miny + volinfo1.YMax()-volinfo1.YMin();
	  bbox.maxz = bbox.minz + volinfo1.ZMax()-volinfo1.ZMin();
	
/*	  VolMagick::Dimension dim;
	  dim.xdim = (int) ((bbox.maxx-bbox.minx)/ span[0])+1;
	  dim.ydim = (int) ((bbox.maxy-bbox.miny)/ span[1])+1;
	  dim.zdim = (int) ((bbox.maxz-bbox.minz)/ span[2])+1;
*/

 	
      outputVol.voxelType(inputVol.voxelType());
      outputVol.dimension(volinfo1.dimension());
      outputVol.boundingBox(bbox);
      
      
/*	 float temp;
	 int i, j, k;
     int xsh = (int)((bbox.minx - inputVol.XMin())/span[0]);
     int ysh = (int)((bbox.miny - inputVol.YMin())/span[1]);
     int zsh = (int)((bbox.minz - inputVol.ZMin())/span[2]);
*/	 

	  for( int kz = 0; kz<outputVol.ZDim(); kz++)
	   for( int jy = 0; jy<outputVol.YDim(); jy++)
	     for( int ix = 0; ix<outputVol.XDim(); ix++)
		    {
		//		i = ix + xsh;
		//		j = jy + ysh;
		//		k = kz + zsh;
		//		cout <<"ijk "<< i <<" " << j <<" " <<k <<endl;
		//		if(i<0 || i >= inputVol.XDim()|| j<0 || j>= inputVol.YDim() || k <0 || k>=inputVol.ZDim()) outputVol(ix, jy, kz, 0.0);
		//		else
				outputVol(ix,jy,kz, inputVol(ix,jy,kz)  );
			}
	//		stringstream s;
	//		s<<argv[3]<< num <<".rawiv";
	      VolMagick::createVolumeFile(outputVol, argv[5]);
    

    std::cout<<"done!"<<std::endl;


    }

  catch(VolMagick::Exception &e)
    {
      std:: cerr << e.what() << std::endl;
    }
  catch(std::exception &e)
    {
      std::cerr << e.what() << std::endl;
    }

  return 0;
}

int main(int argc, char **argv)
{
  if(argc < 5)
    {
      std:: cerr << 
	"Usage: " << argv[0] << 

"  inputfile NewMin NewMax outputFile \n";
      return 1;
    }

  try
    {
      VolMagick::Volume inputVol;

      VolMagick::Volume inputVol2;
      
      VolMagick::Volume outputVol;

      VolMagick::readVolumeFile(inputVol,argv[1]); ///first argument is input volume
      
      

  //    VolMagick::VolumeFileInfo volinfo1;
  //    volinfo1.read(argv[1]);
  //    std::cout << volinfo1.filename() << ":" <<std::endl;

      
      outputVol.voxelType(inputVol.voxelType());
      outputVol.dimension(inputVol.dimension());
      outputVol.boundingBox(inputVol.boundingBox());
      
      
      std::cout<<"voxeltype: "<<inputVol.voxelType()<<std::endl;
      std::cout<<"InputVol min, max: " << inputVol.min() << ", " << inputVol.max() << std::endl;

     float newMin = atof(argv[2]);
     float newMax = atof(argv[3]); 
      
      for( int kz = 0; kz<inputVol.ZDim(); kz++)
	{
	  std::cout<<kz<<"..";
	    for( int jy = 0; jy<inputVol.YDim(); jy++)
	      for( int ix = 0; ix<inputVol.XDim(); ix++)
		{
		  
		  outputVol(ix,jy,kz, newMin + (inputVol(ix,jy,kz)-inputVol.min())*newMax/(inputVol.max()-inputVol.min())  );
		  
		}
	}	
      

      VolMagick::createVolumeFile(argv[argc-1], outputVol);

  //    VolMagick::writeVolumeFile(outputVol, argv[argc-1]);



     std::cout<< std::endl;

    }

  catch(VolMagick::Exception &e)
    {
      std:: cerr << e.what() << std::endl;
    }
  catch(std::exception &e)
    {
      std::cerr << e.what() << std::endl;
    }

  return 0;
}