コード例 #1
0
ファイル: BackGround.cpp プロジェクト: qjxkid/bkg_split
void BackGround::GetBackground_One_pass( string srcfilename,string outputdir,unsigned int width,unsigned int height, cv::Size win_stride)
{
	Init(width,height);
	LoadPictures(srcfilename);
	SetOutputDir(outputdir);

	string filepath;
	ifstream fin(m_srcfilename.c_str(),ios_base::in);
	if(!fin.is_open())
	{
#ifdef DEBUG_OUTPUT
		cout<<"Open File Error"<<endl;
#endif
		exit(1);
	}
	cv::Mat tmpimg;
	while(getline(fin,filepath))
	{
		m_input.release();
		tmpimg=cv::imread(filepath,0);
		cv::copyMakeBorder(tmpimg,m_input,40,40,40,40,cv::BORDER_REPLICATE);
		SetPrefix(GetFileName(filepath.c_str()));
		OutputBackground_OnePass(win_stride);
	}
	fin.close();
}
コード例 #2
0
ファイル: BackGround.cpp プロジェクト: qjxkid/bkg_split
void BackGround::InitOutputPerBackground(string srcfilename,string outputdir,unsigned int width,unsigned int height,double scale,double scalefactor,double step)
{
	Init(width,height);
	LoadPictures(srcfilename);
	SetOutputDir(outputdir);

	m_fin.open(m_srcfilename.c_str(),ios_base::in);
	if(!m_fin.is_open())
	{
#ifdef DEBUG_OUTPUT
		cout<<"Open File Error"<<endl;
#endif
		exit(1);
	}

	m_currentroi.width=m_bgroi.width;
	m_currentroi.height=m_bgroi.height;

	m_scale=scale;
	m_scalefactor=scalefactor;
	m_step=step;
}
コード例 #3
0
ファイル: BackGround.cpp プロジェクト: qjxkid/bkg_split
void BackGround::GetBackground(string srcfilename,string outputdir,unsigned int width,unsigned int height,double scale,double scalefactor,double step)
{
	Init(width,height);
	LoadPictures(srcfilename);
	SetOutputDir(outputdir);

	string filepath;
	ifstream fin(m_srcfilename.c_str(),ios_base::in);
	if(!fin.is_open())
	{
#ifdef DEBUG_OUTPUT
		cout<<"Open File Error"<<endl;
#endif
		exit(1);
	}
	while(getline(fin,filepath))
	{
		m_input.release();
		m_input=cv::imread(filepath,0);
		SetPrefix(GetFileName(filepath.c_str()));
		OutputBackground(scale,scalefactor,step);
	}
	fin.close();
}
コード例 #4
0
// Radomized trials for registering a point cloud and mesh
//  sample noise is dependent on surface normal orientation
//  (assumes mesh itself has no measurement noise)
void Run_ParameterizedTest_Mesh_SurfaceNoise(TestParameters params)
{
  std::stringstream ss;

  std::string loadSourceMeshPath = params.inputDir + "/" + params.sourceMeshFile;
  std::string loadTargetMeshPath = params.inputDir + "/" + params.targetMeshFile;
  std::string saveSourceMeshPath = params.outputCommonDir + "/SaveMeshSource";
  std::string saveTargetMeshPath = params.outputCommonDir + "/SaveMeshTarget";
  std::string saveNoisyTargetMeshPath = params.outputCommonDir + "/SaveMeshTargetNoisy";
  std::string saveTargetCov = params.outputCommonDir + "/SaveTargetCov.txt";

  // test parameters
  params.GenerateSamplesFunc = GenerateSamplePointSet_PointCloud_SurfaceNoise;
  CustomTestParams_PointCloud_SurfaceNoise &customParams
    = dynamic_cast<CustomTestParams_PointCloud_SurfaceNoise&> (*params.pCustomTestParams);

  // load target mesh
  cisstMesh mesh_target;
  CreateMesh(mesh_target, loadTargetMeshPath, &saveTargetMeshPath);

  // load source mesh
  //  NOTE: the sample point set is randomly generated from this mesh
  cisstMesh mesh_source;
  CreateMesh(mesh_source, loadSourceMeshPath, &saveSourceMeshPath);

  // generate noisy target mesh
  //  NOTE: the sample point set is registered to this mesh
  cisstMesh noisyTargetMesh;
  if (params.noiseMeshSD != 0.0)
  {
    std::cout << "ERROR: noisy mesh currently disabled" << std::endl;
    return;
    //std::string normRVFile = params.inputDir + "/GaussianValues.txt";
    //std::ifstream randnStream_MeshNoise(normRVFile.c_str());
    //GenerateNoisyMesh(mesh_target, noisyTargetMesh, randnStream_MeshNoise, params.noiseMeshSD, &saveNoisyTargetMeshPath);
  }
  else
  {
    noisyTargetMesh = mesh_target;
  }

  // build mesh covariance tree from noisy mesh
  cisstCovTree_Mesh   *pTree;
  int    nThresh = 5;       // Cov Tree Params
  double diagThresh = 5.0;  //  ''
  std::cout << "Building covariance tree .... " << std::endl;
  pTree = new cisstCovTree_Mesh(noisyTargetMesh, nThresh, diagThresh);
  std::cout << "Tree built: NNodes=" << pTree->NumNodes() << " NData=" << pTree->NumData()
    << " TreeDepth=" << pTree->TreeDepth() << std::endl;
  assert(pTree->NumNodes());

  // Apply target noise model
  if (customParams.bTargetCov_ApplySurfaceModel)
  {
    // define mesh noise model (surface-model)
    noisyTargetMesh.ComputeTriangleNoiseModels(
      customParams.surfaceModel_InPlaneSD,
      customParams.surfaceModel_PerpPlaneSD);

    // save target covariance model
    noisyTargetMesh.SaveTriangleCovariances(saveTargetCov);
  }


  // ICP Options
  cisstICP::Options opt_ICP;
  opt_ICP.auxOutputDir = params.outputBaseDir + "/AuxiliaryFiles/";
  opt_ICP.maxIter = 100;
  opt_ICP.termHoldIter = 2;
  opt_ICP.minE = -std::numeric_limits<double>::max();
  opt_ICP.tolE = 0.0;
  opt_ICP.dPosThresh = 0.1;
  opt_ICP.dAngThresh = 0.1*(cmnPI / 180);
  opt_ICP.dPosTerm = 0.001;
  opt_ICP.dAngTerm = 0.001*(cmnPI / 180);
  params.opt_ICP = opt_ICP;

#define nNoises     9
#define nOffsets    2
#define nTests      (nNoises*nOffsets)
  //#define nOutliers   6
  //#define nTests      (nNoises*nOffsets*nOutliers)
  //double percentOutliers[nOutliers] = { 0.05, 0.1, 0.2, 0.3, 0.4, 0.5 };

  double noiseInPlaneSDArr[nNoises] = { 0.5, 1.0, 2.0, 0.5, 1.0, 0.5, 1.0, 2.0, 2.0 };
  double noisePerpPlaneSDArr[nNoises] = { 0.5, 1.0, 2.0, 1.0, 2.0, 2.0, 0.5, 1.0, 0.5 };
  //double noiseInPlaneSDArr[nNoises] = { 0.5, 1.0 };
  //double noisePerpPlaneSDArr[nNoises] = { 0.5, 1.0 };

  double minOffsetAngArr[nOffsets] = { 30, 15 }; //{ 10, 30 }; //{0,  10, 30, 60};
  double maxOffsetAngArr[nOffsets] = { 60, 30 }; //{ 30, 60 }; //{10, 30, 60, 90};
  double minOffsetPosArr[nOffsets] = { 30, 15 }; //{ 10, 30 }; //{0,  10, 30, 60};
  double maxOffsetPosArr[nOffsets] = { 60, 30 }; //{ 30, 60 }; //{10, 30, 60, 100};

  std::vector<unsigned int> randSeed_SamplesArr(nTests, 0);   // sample generater
  std::vector<unsigned int> randSeed_XfmsArr(nTests, 0);     // initial offset xfm generater

  for (unsigned int i = 0; i < nTests; i++)
  {
    randSeed_SamplesArr[i] = i + 23;
    randSeed_XfmsArr[i] = i + 127;
  }

  std::string outputCommonDir = params.outputCommonDir;
  params.nSamples = customParams.nGoodSamples;

  //--- Parameterized Trials ---//

  for (unsigned int offset = 0; offset < nOffsets; offset++)
  {
    for (unsigned int noise = 0; noise < nNoises; noise++)
    {
      unsigned int testNum = offset*nNoises + noise;

      ss.str("");
      ss << "Noise_Prll" << noiseInPlaneSDArr[noise] << "Perp" << noisePerpPlaneSDArr[noise]
        << "_Offset_R" << minOffsetAngArr[offset] << "-" << maxOffsetAngArr[offset]
        << "T" << minOffsetPosArr[offset] << "-" << maxOffsetPosArr[offset];
      //<< "_Outliers" << percentOutliers[outlier];
      std::string outputSubFolder = ss.str();

      params.minOffsetAng = minOffsetAngArr[offset];
      params.maxOffsetAng = maxOffsetAngArr[offset];
      params.minOffsetPos = minOffsetPosArr[offset];
      params.maxOffsetPos = maxOffsetPosArr[offset];
      params.randSeed_Samples = randSeed_SamplesArr[testNum];
      params.randSeed_Xfms = randSeed_XfmsArr[testNum];

      customParams.sampleNoise_InPlaneSD = noiseInPlaneSDArr[noise];
      customParams.sampleNoise_PerpPlaneSD = noisePerpPlaneSDArr[noise];

      // hold number of good samples constant and increase sample size to
      //  achieve the desired percentage of outliers
      //double p = percentOutliers[outlier];
      //unsigned int nOutlierSamps = (unsigned int)(p/(1-p) * customParams.nGoodSamples);
      //params.nSamples = customParams.nGoodSamples + nOutlierSamps;      


      // TODO: remove change to output common files to separate directories below

      // Run StdICP
      {
        params.AlgorithmDescription = "StdICP";
        //params.AlgorithmDescription = "StdICP_Verbose";
        params.algType = TestParameters::StdICP;
        SetOutputDir(params, outputCommonDir, outputSubFolder);

        vctDynamicVector<vct3> dummySamples;      // these will be set later by the sample generator routine
        params.pAlg = new cisstAlgorithmICP_StdICP_Mesh(pTree, dummySamples);
        Run_ParameterizedTest(mesh_source, pTree, params);
        delete params.pAlg; params.pAlg = NULL;
      }

      // Run IMLP
      {
        params.AlgorithmDescription = "IMLP";
        //params.AlgorithmDescription = "IMLP_Verbose";
        params.algType = TestParameters::IMLP;
        SetOutputDir(params, outputCommonDir, outputSubFolder);

        vctDynamicVector<vct3> dummySamples;      // these will be set later by the sample generator routine
        vctDynamicVector<vct3x3> dummySampleCov;  //  ''
        cisstAlgorithmICP_IMLP_Mesh *pAlg =
          new cisstAlgorithmICP_IMLP_Mesh(
          pTree, dummySamples, dummySampleCov, dummySampleCov, customParams.outlier_ChiSquareThreshold);          
        params.pAlg = pAlg;
        Run_ParameterizedTest(mesh_source, pTree, params);
        delete params.pAlg; params.pAlg = NULL;
      }

      // Run IMLP_MD (Mahalanobis Distance Match Criteria)
      {
        params.AlgorithmDescription = "IMLP-MD";
        //params.AlgorithmDescription = "IMLP-MD_Verbose";
        params.algType = TestParameters::IMLP;
        SetOutputDir(params, outputCommonDir, outputSubFolder);

        vctDynamicVector<vct3> dummySamples;      // these will be set later by the sample generator routine
        vctDynamicVector<vct3x3> dummySampleCov;  //  ''
        cisstAlgorithmICP_IMLP_MahalDist_Mesh *pAlg =
          new cisstAlgorithmICP_IMLP_MahalDist_Mesh(
          pTree, dummySamples, dummySampleCov, dummySampleCov, customParams.outlier_ChiSquareThreshold);
        params.pAlg = pAlg;
        Run_ParameterizedTest(mesh_source, pTree, params);
        delete params.pAlg; params.pAlg = NULL;
      }

      // Run IMLP_CP (Closest Point Match Criteria)
      {
        params.AlgorithmDescription = "IMLP-CP";
        //params.AlgorithmDescription = "IMLP-CP_Verbose";
        params.algType = TestParameters::IMLP;
        SetOutputDir(params, outputCommonDir, outputSubFolder);

        vctDynamicVector<vct3> dummySamples;      // these will be set later by the sample generator routine
        vctDynamicVector<vct3x3> dummySampleCov;  //  ''
        cisstAlgorithmICP_IMLP_ClosestPoint_Mesh *pAlg =
          new cisstAlgorithmICP_IMLP_ClosestPoint_Mesh(
          pTree, dummySamples, dummySampleCov, dummySampleCov, customParams.outlier_ChiSquareThreshold);
        params.pAlg = pAlg;
        Run_ParameterizedTest(mesh_source, pTree, params);
        delete params.pAlg; params.pAlg = NULL;
      }

    }
  }
}
コード例 #5
0
// Radomized trials for registering 2 point clouds
//  sample noise is dependent on surface normal orientation
//  (assumes mesh itself has no measurement noise)
void Run_ParameterizedTest_PointCloud_SurfaceNoise(TestParameters params)
{
  std::stringstream ss;

  //std::string workingDir = "../ICP_TestData";
  //std::string baseOutputFolder = "RandomTestData_PointCloud_SurfaceNoise";  // "RandomTests_Plane2Plane_Term0.001G_5.0,0.5_ChiSqu0.95_A0_Sigma2/";
  //std::string sourceMeshFile = "RIGHTHEMIPELVIS_centered.mesh";
  //std::string targetMeshFile = sourceMeshFile;

  //// Create folders for output files
  //std::string baseOutputDir = workingDir + "/" + baseOutputFolder;
  //std::string commonOutputDir = baseOutputDir + "/CommonFiles";
  //CreateDir(baseOutputDir);
  //CreateDir(commonOutputDir);

  std::string loadSourceMeshPath = params.inputDir + "/" + params.sourceMeshFile;
  std::string loadTargetMeshPath = params.inputDir + "/" + params.targetMeshFile;
  std::string saveSourceMeshPath = params.outputCommonDir + "/SaveMeshSource";
  std::string saveTargetMeshPath = params.outputCommonDir + "/SaveMeshTarget";
  std::string saveNoisyTargetMeshPath = params.outputCommonDir + "/SaveMeshTargetNoisy";

  //// test parameters
  //TestParameters params;
  //params.TestDescription = "Run_ParameterizedTest_PointCloud_SurfaceNoise";
  //params.inputDir = workingDir;
  //params.sourceMeshFile = sourceMeshFile;
  //params.targetMeshFile = targetMeshFile;
  //params.numTrials = 2; // 300;
  //params.nSamples = 100;
  //params.nValidationSamples = 100;
  //params.noiseMeshSD = 0.0;
  //params.randSeed_MeshNoise = 0;
  params.GenerateSamplesFunc = GenerateSamplePointSet_PointCloud_SurfaceNoise;
  CustomTestParams_PointCloud_SurfaceNoise &customParams
    = dynamic_cast<CustomTestParams_PointCloud_SurfaceNoise&> (*params.pCustomTestParams);

  //// custom test parameters
  //// NOTE: target point cloud noise model
  ////        perpendicular noise must be specified
  ////        in-plane noise is set to avg distance from triangle center to each vertex
  //CustomTestParams_PointCloud_SurfaceNoise customParams;
  //params.pCustomTestParams = &customParams;
  //customParams.percentOutliers = 0.0;
  //customParams.bSampleCov_ApplyNoiseModel = true;
  //customParams.bSampleCov_ApplySurfaceModel = true;
  //customParams.bTargetCov_ApplySurfaceModel = true;
  //customParams.bTargetCov_DynamicSurfaceModel = false;
  //customParams.surfaceModel_InPlaneSD = 5.0;
  //customParams.surfaceModel_PerpPlaneSD = 0.5;
  //customParams.minPosOffsetOutlier = 10.0;
  //customParams.maxPosOffsetOutlier = 20.0;

  // load target mesh
  cisstMesh mesh_target;
  CreateMesh(mesh_target, loadTargetMeshPath, &saveTargetMeshPath);

  // load source mesh
  //  NOTE: the sample point set is randomly generated from this mesh
  cisstMesh mesh_source;
  CreateMesh(mesh_source, loadSourceMeshPath, &saveSourceMeshPath);

  // generate noisy target mesh
  //  NOTE: the sample point set is registered to this mesh
  cisstMesh noisyTargetMesh;
  if (params.noiseMeshSD > 0.0)
  {
    std::cout << "ERROR: noisy mesh currently disabled" << std::endl;
    return;
    //std::string normRVFile = params.inputDir + "/GaussianValues.txt";
    //std::ifstream randnStream_MeshNoise(normRVFile.c_str());
    //GenerateNoisyMesh(mesh_target, noisyTargetMesh, randnStream_MeshNoise, params.noiseMeshSD, &saveNoisyTargetMeshPath);
  }
  else
  {
    noisyTargetMesh = mesh_target;
  }

  // build point cloud covariance tree from noisy mesh
  //  and define point cloud noise model (but don't add more noise)
  cisstCovTree_PointCloud   *pTree;
  int    nThresh = 5;       // Cov Tree Params
  double diagThresh = 5.0;  //  ''
  std::cout << "Building covariance tree .... " << std::endl;
  double targetModel_InPlaneSD = params.noiseMeshSD;
  double targetModel_PerpPlaneSD = params.noiseMeshSD;
  if (customParams.bTargetCov_ApplySurfaceModel)
  {
    targetModel_InPlaneSD += customParams.surfaceModel_InPlaneSD;
    targetModel_PerpPlaneSD += customParams.surfaceModel_PerpPlaneSD;
  }
  if (customParams.bTargetCov_DynamicSurfaceModel && customParams.bTargetCov_ApplySurfaceModel)
  {
    // set target surface noise model dynamically from mesh
    pTree = new cisstCovTree_PointCloud(noisyTargetMesh, nThresh, diagThresh, targetModel_PerpPlaneSD);
    std::cout << "Tree built: NNodes=" << pTree->NumNodes() << " NData=" << pTree->NumData()
      << " TreeDepth=" << pTree->TreeDepth() << std::endl;
    std::cout << " Point Cloud Noise Model:" << std::endl
      << "  perp-plane variance = " << pow(customParams.surfaceModel_PerpPlaneSD, 2) << std::endl
      << "  in-plane variance = " << pTree->avgVarInPlane << " (avg)" << std::endl;
    assert(pTree->NumNodes());
  }
  else
  {
    // set static target surface noise model
    pTree = new cisstCovTree_PointCloud(noisyTargetMesh, nThresh, diagThresh, targetModel_PerpPlaneSD, targetModel_InPlaneSD);
    std::cout << "Tree built: NNodes=" << pTree->NumNodes() << " NData=" << pTree->NumData()
      << " TreeDepth=" << pTree->TreeDepth() << std::endl;
    std::cout << " Point Cloud Noise Model:" << std::endl
      << "  perp-plane variance = " << pow(customParams.surfaceModel_PerpPlaneSD, 2) << std::endl
      << "  in-plane variance = " << pow(customParams.surfaceModel_InPlaneSD, 2) << std::endl;
    assert(pTree->NumNodes());
  }
  // save target point cloud and covariance model
  std::string saveTargetPointCloud = params.outputCommonDir + "/SaveTargetPointCloud.pts";
  std::string saveTargetCov = params.outputCommonDir + "/SaveTargetCov.txt";
  pTree->SavePointCloud(saveTargetPointCloud);
  pTree->SavePointCloudCov(saveTargetCov);

  // ICP Options
  cisstICP::Options opt_ICP;
  opt_ICP.auxOutputDir = params.outputBaseDir + "/AuxiliaryFiles/";
  opt_ICP.maxIter = 100;
  opt_ICP.termHoldIter = 2;
  opt_ICP.minE = -std::numeric_limits<double>::max();
  opt_ICP.tolE = 0.0;
  opt_ICP.dPosThresh = 0.1;
  opt_ICP.dAngThresh = 0.1*(cmnPI / 180);
  opt_ICP.dPosTerm = 0.001;
  opt_ICP.dAngTerm = 0.001*(cmnPI / 180);
  params.opt_ICP = opt_ICP;

  //// CPD Options
  //CPD::Options opt_CPD;
  //opt_CPD.maxIter = opt_ICP.maxIter;
  //opt_CPD.termHoldIter = opt_ICP.termHoldIter;
  //opt_CPD.minE = opt_ICP.minE;
  //opt_CPD.tolE = opt_ICP.tolE;
  //opt_CPD.dPosThresh = opt_ICP.dPosThresh;
  //opt_CPD.dAngThresh = opt_ICP.dAngThresh;
  //opt_CPD.dPosTerm = opt_ICP.dPosTerm;
  //opt_CPD.dAngTerm = opt_ICP.dAngTerm;
  //opt_CPD.w = customParams.w;
  //params.opt_CPD = opt_CPD;

#define nNoises     9
#define nOffsets    2
#define nTests      (nNoises*nOffsets)
  //#define nOutliers   6
  //#define nTests      (nNoises*nOffsets*nOutliers)
  //double percentOutliers[nOutliers] = { 0.05, 0.1, 0.2, 0.3, 0.4, 0.5 };

  double noiseInPlaneSDArr[nNoises] = { 0.5, 1.0, 2.0, 0.5, 1.0, 0.5, 1.0, 2.0, 2.0 };
  double noisePerpPlaneSDArr[nNoises] = { 0.5, 1.0, 2.0, 1.0, 2.0, 2.0, 0.5, 1.0, 0.5 };
  //double noiseInPlaneSDArr[nNoises] = { 0.5, 1.0 };
  //double noisePerpPlaneSDArr[nNoises] = { 0.5, 1.0 };

  double minOffsetAngArr[nOffsets] = { 30, 15 }; //{ 10, 30 }; //{0,  10, 30, 60};
  double maxOffsetAngArr[nOffsets] = { 60, 30 }; //{ 30, 60 }; //{10, 30, 60, 90};
  double minOffsetPosArr[nOffsets] = { 30, 15 }; //{ 10, 30 }; //{0,  10, 30, 60};
  double maxOffsetPosArr[nOffsets] = { 60, 30 }; //{ 30, 60 }; //{10, 30, 60, 100};

  std::vector<unsigned int> randSeed_SamplesArr(nTests, 0);   // sample generater
  std::vector<unsigned int> randSeed_XfmsArr(nTests, 0);     // initial offset xfm generater

  for (unsigned int i = 0; i < nTests; i++)
  {
    randSeed_SamplesArr[i] = i + 23;
    randSeed_XfmsArr[i] = i + 127;
  }

  std::string outputCommonDir = params.outputCommonDir;
  params.nSamples = customParams.nGoodSamples;

  //--- Parameterized Trials ---//

  for (unsigned int offset = 0; offset < nOffsets; offset++)
  {
    for (unsigned int noise = 0; noise < nNoises; noise++)
    {
      unsigned int testNum = offset*nNoises + noise;

      ss.str("");
      ss << "Noise_Prll" << noiseInPlaneSDArr[noise] << "Perp" << noisePerpPlaneSDArr[noise]
        << "_Offset_R" << minOffsetAngArr[offset] << "-" << maxOffsetAngArr[offset]
        << "T" << minOffsetPosArr[offset] << "-" << maxOffsetPosArr[offset];
      //<< "_Outliers" << percentOutliers[outlier];
      std::string outputSubFolder = ss.str();

      params.minOffsetAng = minOffsetAngArr[offset];
      params.maxOffsetAng = maxOffsetAngArr[offset];
      params.minOffsetPos = minOffsetPosArr[offset];
      params.maxOffsetPos = maxOffsetPosArr[offset];
      params.randSeed_Samples = randSeed_SamplesArr[testNum];
      params.randSeed_Xfms = randSeed_XfmsArr[testNum];

      customParams.sampleNoise_InPlaneSD = noiseInPlaneSDArr[noise];
      customParams.sampleNoise_PerpPlaneSD = noisePerpPlaneSDArr[noise];

      // hold number of good samples constant and increase sample size to
      //  achieve the desired percentage of outliers
      //double p = percentOutliers[outlier];
      //unsigned int nOutlierSamps = (unsigned int)(p/(1-p) * customParams.nGoodSamples);
      //params.nSamples = customParams.nGoodSamples + nOutlierSamps;      


      // TODO: remove change to output common files to separate directories below

      // Run StdICP
      {
        params.AlgorithmDescription = "StdICP";
        //params.AlgorithmDescription = "StdICP_Verbose";
        params.algType = TestParameters::StdICP;
        SetOutputDir(params, outputCommonDir, outputSubFolder);

        vctDynamicVector<vct3> dummySamples;      // these will be set later by the sample generator routine
        params.pAlg = new cisstAlgorithmICP_StdICP_PointCloud(pTree, dummySamples);
        Run_ParameterizedTest(mesh_source, pTree, params);
        delete params.pAlg; params.pAlg = NULL;
      }

      // Run IMLP
      {
        params.AlgorithmDescription = "IMLP";
        //params.AlgorithmDescription = "IMLP_Verbose";
        params.algType = TestParameters::IMLP;
        SetOutputDir(params, outputCommonDir, outputSubFolder);

        vctDynamicVector<vct3> dummySamples;      // these will be set later by the sample generator routine
        vctDynamicVector<vct3x3> dummySampleCov;  //  ''
        cisstAlgorithmICP_IMLP_PointCloud *pAlg =
          new cisstAlgorithmICP_IMLP_PointCloud(
          pTree, dummySamples, dummySampleCov, dummySampleCov, customParams.outlier_ChiSquareThreshold);          
        params.pAlg = pAlg;
        Run_ParameterizedTest(mesh_source, pTree, params);
        delete params.pAlg; params.pAlg = NULL;
      }

      // Run IMLP_MD (Mahalanobis Distance Match Criteria)
      {
        params.AlgorithmDescription = "IMLP-MD";
        //params.AlgorithmDescription = "IMLP-MD_Verbose";
        params.algType = TestParameters::IMLP;
        SetOutputDir(params, outputCommonDir, outputSubFolder);

        vctDynamicVector<vct3> dummySamples;      // these will be set later by the sample generator routine
        vctDynamicVector<vct3x3> dummySampleCov;  //  ''
        cisstAlgorithmICP_IMLP_MahalDist_PointCloud *pAlg =
          new cisstAlgorithmICP_IMLP_MahalDist_PointCloud(
          pTree, dummySamples, dummySampleCov, dummySampleCov, customParams.outlier_ChiSquareThreshold);
        params.pAlg = pAlg;
        Run_ParameterizedTest(mesh_source, pTree, params);
        delete params.pAlg; params.pAlg = NULL;
      }

      // Run IMLP_CP (Closest Point Match Criteria)
      {
        params.AlgorithmDescription = "IMLP-CP";
        //params.AlgorithmDescription = "IMLP-CP_Verbose";
        params.algType = TestParameters::IMLP;
        SetOutputDir(params, outputCommonDir, outputSubFolder);

        vctDynamicVector<vct3> dummySamples;      // these will be set later by the sample generator routine
        vctDynamicVector<vct3x3> dummySampleCov;  //  ''
        cisstAlgorithmICP_IMLP_ClosestPoint_PointCloud *pAlg =
          new cisstAlgorithmICP_IMLP_ClosestPoint_PointCloud(
          pTree, dummySamples, dummySampleCov, dummySampleCov, customParams.outlier_ChiSquareThreshold);
        params.pAlg = pAlg;
        Run_ParameterizedTest(mesh_source, pTree, params);
        delete params.pAlg; params.pAlg = NULL;
      }

    }
  }
}
コード例 #6
0
ファイル: setup.c プロジェクト: Sportsfan77777/vortex
/* ********************************************************************* */
int Setup (Input *input, Cmd_Line *cmd_line, char *ini_file)
/*!
 * Open and parse the initialization file. 
 * Assign values to the input structure.
 *
 * \param [out]  input     pointer to an Input structure
 * \param [in]   cmd_line  pointer to a Cmd_Line structure (useful, e.g.,
 *                         to resize the domain using the \c -xres option)
 * \param [in]   ini_file  the name of the initialization file (default
 *                         is "pluto.ini") specified with the \c -i option.
 *
 *********************************************************************** */
{
  int    idim, ip, ipos, itype, nlines;
  char   *bound_opt[NOPT], str_var[512], *str;
  char  *glabel[]     = {"X1-grid", "X2-grid","X3-grid"};
  char  *bbeg_label[] = {"X1-beg", "X2-beg","X3-beg"};
  char  *bend_label[] = {"X1-end", "X2-end","X3-end"};
  double dbl_var, rx;
  Output *output;
  FILE *fp;

  for (itype = 0; itype < NOPT; itype++) {
    bound_opt[itype] = "0000";
  }

/*  ---------------------------------------------------
      available options are given as two set of names;
      This facilitates when updating the code and
      people are too lazy to read the manual !
    --------------------------------------------------- */

  bound_opt[OUTFLOW]      = "outflow";
  bound_opt[REFLECTIVE]   = "reflective";
  bound_opt[AXISYMMETRIC] = "axisymmetric";
  bound_opt[EQTSYMMETRIC] = "eqtsymmetric";
  bound_opt[PERIODIC]     = "periodic";
  bound_opt[SHEARING]     = "shearingbox";
  bound_opt[USERDEF]      = "userdef";

  input->log_freq = 1; /* -- default -- */
 
  nlines = ParamFileRead(ini_file);

/* ------------------------------------------------------------
                        [Grid] Section 
   ------------------------------------------------------------ */

  for (idim = 0; idim < 3; idim++){
    input->npatch[idim] = atoi(ParamFileGet(glabel[idim], 1));
    input->npoint[idim] = 0;

    ipos = 1;
    for (ip = 1; ip <= input->npatch[idim]; ip++) {

      input->patch_left_node[idim][ip] = atof(ParamFileGet(glabel[idim], ++ipos));
      input->patch_npoint[idim][ip]    = atoi(ParamFileGet(glabel[idim], ++ipos));
      input->npoint[idim]             += input->patch_npoint[idim][ip];
      input->grid_is_uniform[idim]     = 0;

      strcpy (str_var, ParamFileGet(glabel[idim], ++ipos)); 
/*
printf ("%f  %d %s\n",input->patch_left_node[idim][ip],input->patch_npoint[idim][ip],str_var);
*/
      if (strcmp(str_var,"u") == 0 || strcmp(str_var,"uniform") == 0) {
        input->patch_type[idim][ip] = UNIFORM_GRID;
        if (input->npatch[idim] == 1) input->grid_is_uniform[idim] = 1;        
      }else if (strcmp(str_var,"s") == 0 || strcmp(str_var,"strecthed") == 0) { 
        input->patch_type[idim][ip] = STRETCHED_GRID;
      }else if (strcmp(str_var,"l+") == 0){
        input->patch_type[idim][ip] = LOGARITHMIC_INC_GRID;
      }else if (strcmp(str_var,"l-") == 0){
        input->patch_type[idim][ip] = LOGARITHMIC_DEC_GRID;
      }else{ 
        printf ("\nSetup: You must specify either 'u', 's', 'l+' or 'l-' as grid-type in %s\n",
                ini_file);
        QUIT_PLUTO(1);
      }
    }
    
    input->patch_left_node[idim][ip] = atof(ParamFileGet(glabel[idim], ++ipos));

    if ( (ipos+1) != (input->npatch[idim]*3 + 3)) {
      printf ("! Setup: domain #%d setup is not properly defined \n", idim);
      QUIT_PLUTO(1);
    }
    if (idim >= DIMENSIONS && input->npoint[idim] != 1) {
      printf ("! Setup: %d point(s) on dim. %d is NOT valid, resetting to 1\n",
              input->npoint[idim],idim+1);
      input->npoint[idim]          = 1;
      input->npatch[idim]          = 1;
      input->patch_npoint[idim][1] = 1;
    }
  }

/* ------------------------------------------------------------
      Change the resolution if cmd_line->xres has been given
   ------------------------------------------------------------ */

  if (cmd_line->xres > 1) {
    rx =  (double)cmd_line->xres/(double)input->patch_npoint[IDIR][1];
    for (idim = 0; idim < DIMENSIONS; idim++){
      if (input->npatch[idim] > 1){  
        printf ("! Setup: -xres option works on uniform, single patch grid\n");
        QUIT_PLUTO(1);
      }
      
      dbl_var = (double)input->patch_npoint[idim][1];
      input->patch_npoint[idim][1] = MAX( (int)(dbl_var*rx), 1);
      dbl_var = (double)input->npoint[idim];
      input->npoint[idim] = MAX( (int)(dbl_var*rx), 1); 
    }  
  }

/* ------------------------------------------------------------
                     [Time] Section 
   ------------------------------------------------------------ */

  input->cfl         = atof(ParamFileGet("CFL", 1));

  if (ParamExist ("CFL_par")) input->cfl_par = atof(ParamFileGet("CFL_par", 1));
  else                            input->cfl_par = 0.8/(double)DIMENSIONS;

  if (ParamExist ("rmax_par")) input->rmax_par = atof(ParamFileGet("rmax_par", 1));
  else                             input->rmax_par = 100.0;

  input->cfl_max_var = atof(ParamFileGet("CFL_max_var", 1));
  input->tstop       = atof(ParamFileGet("tstop", 1));
  input->first_dt    = atof(ParamFileGet("first_dt", 1));

/* ------------------------------------------------------------
                     [Solver] Section 
   ------------------------------------------------------------ */

  sprintf (input->solv_type,"%s",ParamFileGet("Solver",1));

/* ------------------------------------------------------------
                     [Boundary] Section 
   ------------------------------------------------------------ */

  for (idim = 0; idim < 3; idim++){

    str = ParamFileGet(bbeg_label[idim], 1);
    COMPARE (str, bound_opt[itype], itype);
    if (itype == NOPT) {
      printf ("! Setup: don't know how to put left boundary '%s'  \n", str);
      QUIT_PLUTO(1);
    }
    input->lft_bound_side[idim] = itype;
  }

  for (idim = 0; idim < 3; idim++){

    str = ParamFileGet(bend_label[idim], 1);
    COMPARE (str, bound_opt[itype], itype);
    if (itype == NOPT) {
      printf ("! Setup: don't know how to put left boundary '%s'  \n", str);
      QUIT_PLUTO(1);
    }
    input->rgt_bound_side[idim] = itype;
  }

/* ------------------------------------------------------------
                     [Output] Section 
   ------------------------------------------------------------ */

  input->user_var = atoi(ParamFileGet("uservar", 1));
  for (ip = 0; ip < input->user_var; ip++){

    if ( (str = ParamFileGet("uservar", 2 + ip)) != NULL){
      sprintf (input->user_var_name[ip], "%s", str);
    }else{
      printf ("! Setup: missing name after user var name '%s'\n", 
              input->user_var_name[ip-1]);
      QUIT_PLUTO(1);
    } 
  }

/* ---- set output directory ---- */

  sprintf (input->output_dir, "%s","./");  /* default value is current directory */
  if (ParamExist("output_dir")){
    str = ParamFileGet("output_dir",1);
    sprintf (input->output_dir, "%s",str);
  }
  SetOutputDir(input->output_dir);

/* -- check if we have write access and if the directory exists -- */

  sprintf (str_var,"%s/tmp09123.txt",input->output_dir); /* -- test file -- */
  fp = fopen(str_var,"w");  /* -- open test file for writing -- */
  if (fp == NULL){
    printf ("! Setup: cannot access directory '%s'.\n", input->output_dir);
    printf ("!        Please check that the directory exists\n");
    printf ("!        and you have write permission.\n");
    QUIT_PLUTO(1);
  }else{
    fclose(fp);
    remove(str_var);  /* -- remove file -- */
  }

/* ---- dbl output ---- */

  ipos = 0;
  output = input->output + (ipos++);
  output->type  = DBL_OUTPUT;
  output->cgs   = 0;  /* cannot write .dbl using cgs units */
  GetOutputFrequency(output, "dbl");

  sprintf (output->mode,"%s",ParamFileGet("dbl",3));
  #ifdef USE_ASYNC_IO
   if (    strcmp(output->mode,"single_file") 
        && strcmp(output->mode,"single_file_async")
        && strcmp(output->mode,"multiple_files")){
      printf ("! Setup: expecting 'single_file', 'single_file_async' ");
      printf ("or 'multiple_files' in dbl output\n");
      QUIT_PLUTO(1);
   }
  #else
   if (   strcmp(output->mode,"single_file")
       && strcmp(output->mode,"multiple_files")){
      printf (
      "! Setup: expecting 'single_file' or 'multiple_files' in dbl output\n");
      QUIT_PLUTO(1);
   }     
  #endif

 /* ---- flt output ---- */

  if (ParamExist("flt")){
    output = input->output + (ipos++);
    output->type  = FLT_OUTPUT;
    GetOutputFrequency(output, "flt");

    sprintf (output->mode,"%s",ParamFileGet("flt",3));  
    #ifdef USE_ASYNC_IO
     if (    strcmp(output->mode,"single_file") 
          && strcmp(output->mode,"single_file_async")
          && strcmp(output->mode,"multiple_files")){
        printf ("! Setup: expecting 'single_file', 'single_file_async' ");
        printf ("or 'multiple_files' in flt output\n");
        QUIT_PLUTO(1);
     }
    #else
     if (    strcmp(output->mode,"single_file") 
          && strcmp(output->mode,"multiple_files")){
        printf (
        "! Setup: expecting 'single_file' or 'multiple_files' in flt output\n");
        QUIT_PLUTO(1);
     }  
    #endif
    if (ParamFileHasBoth ("flt","cgs")) output->cgs = 1;
    else                                output->cgs = 0;
  }

 /* -- hdf5 output -- */

  if (ParamExist("dbl.h5")){
    output = input->output + (ipos++);
    output->type  = DBL_H5_OUTPUT;
    output->cgs   = 0;  /* cannot write .h5 using cgs units */
    GetOutputFrequency(output, "dbl.h5");
  }
  if (ParamExist("flt.h5")){
    output = input->output + (ipos++);
    output->type  = FLT_H5_OUTPUT;
    output->cgs   = 0;  /* cannot write .h5 using cgs units */
    GetOutputFrequency(output, "flt.h5");
  }

 /* -- vtk output -- */

  if (ParamExist ("vtk")){
    output = input->output + (ipos++);
    output->type  = VTK_OUTPUT;
    GetOutputFrequency(output, "vtk");

    if (ParamFileGet("vtk",3) == NULL){
      printf ("! Setup: extra field missing in vtk output\n");
      QUIT_PLUTO(1);
    }
    sprintf (output->mode,"%s",ParamFileGet("vtk",3));
    if (   strcmp(output->mode,"single_file")
        && strcmp(output->mode,"multiple_files")){
       printf ("! Setup: expecting 'single_file' or 'multiple_files' in\n");
       printf ("         vtk output\n");
       QUIT_PLUTO(1);
    }
    if (ParamFileHasBoth ("vtk","cgs")) output->cgs = 1;
    else                                output->cgs = 0;
  }

 /* -- tab output -- */

  if (ParamExist ("tab")){
    output = input->output + (ipos++);
    output->type  = TAB_OUTPUT;
    GetOutputFrequency(output, "tab");
    if (ParamFileHasBoth ("tab","cgs")) output->cgs = 1;
    else                                output->cgs = 0;
  }

 /* -- ppm output -- */

  if (ParamExist ("ppm")){
    output = input->output + (ipos++);
    output->type  = PPM_OUTPUT;
    output->cgs   = 0;   /* Cannot write ppm in cgs units */
    GetOutputFrequency(output, "ppm");
  }

 /* -- png output -- */

  if (ParamExist ("png")){
    output = input->output + (ipos++);
    output->type  = PNG_OUTPUT;
    output->cgs   = 0;   /* Cannot write png in cgs units */
    GetOutputFrequency(output, "png");
  }


 /* -- log frequency -- */

  input->log_freq = atoi(ParamFileGet("log", 1));
  input->log_freq = MAX(input->log_freq, 1);
  
 /* -- set default for remaining output type -- */

  while (ipos < MAX_OUTPUT_TYPES){
    output = input->output + ipos;
    output->type   = -1;
    output->cgs    =  0;
    output->dt     = -1.0;
    output->dn     = -1;
    output->dclock = -1.0;
    ipos++;
  }

 /* -- analysis -- */

  if (ParamExist ("analysis")){
    input->anl_dt = atof(ParamFileGet("analysis", 1));
    input->anl_dn = atoi(ParamFileGet("analysis", 2));
  }else{
    input->anl_dt = -1.0;   /* -- defaults -- */
    input->anl_dn = -1;
  }

/* ------------------------------------------------------------
                   [Parameters] Section 
   ------------------------------------------------------------ */

  fp = fopen(ini_file,"r");
  
/* -- find position at "[Parameters" -- */

  for (ipos = 0; ipos <= nlines; ipos++){ 
    fgets(str_var, 512, fp);
    
    if (strlen(str_var) > 0) {
      str = strtok (str_var,"]");
      if (strcmp(str,"[Parameters") == 0) break;
    }
  }

  fgets(str_var, 512, fp); 
  
  for (ip = 0; ip < USER_DEF_PARAMETERS; ip++){
    fscanf (fp,"%s \n", str_var);
    dbl_var = atof(ParamFileGet(str_var,1));
    input->aux[ip] = dbl_var;
    fgets(str_var, sizeof(str_var), fp); /* use fgets to advance to next line */
  }
  fclose(fp);

  return(0);
}