예제 #1
0
 void Visualize(const GraphComponent<Graph>& component, ostream &os,
                const GraphLabeler<Graph> &labeler,
                const GraphColorer<Graph> &colorer,
                const VertexLinker<Graph> &linker) {
     if(paired_) {
         PairedGraphPrinter<Graph> printer(graph_, os, labeler, colorer, linker);
         Visualize(component, printer);
     } else {
         SingleGraphPrinter<Graph> printer(graph_, os, labeler, colorer, linker);
         Visualize(component, printer);
     }
 }
예제 #2
0
 void Visualize(ostream &os,
                const GraphLabeler<Graph> &labeler,
                const GraphColorer<Graph> &colorer,
                const VertexLinker<Graph> &linker) {
     GraphComponent<Graph> component(graph_, graph_.begin(), graph_.end(), false);
     Visualize(component, os, labeler, colorer, linker);
 }
// ============================================================================
int ML_Epetra::MultiLevelPreconditioner::
VisualizeSmoothers(int NumPreCycles, int NumPostCycles)
{

  bool viz = List_.get("viz: enable",false);
  if (viz) {
    if (IsPreconditionerComputed() == false)
      ML_CHK_ERR(-1); // need an already computed preconditioner

    bool VizPreSmoother = false;
    bool VizPostSmoother = false;

    if (NumPreCycles != 0)
      VizPreSmoother = true;
    if (NumPostCycles != 0)
      VizPostSmoother = true;

    int ierr = Visualize(false, VizPreSmoother, VizPostSmoother,
                 false, NumPreCycles, NumPostCycles, -1);

    ML_CHK_ERR(ierr);
  }
  else
  {
    std::cout << PrintMsg_ << "You need to specify `viz: enable' = true" << std::endl;
    std::cout << PrintMsg_ << "in the parameter list before building the ML" << std::endl;
    std::cout << PrintMsg_ << "preconditioner in order to visualize" << std::endl;
    ML_CHK_ERR(-1);
  }

  return(0);
}
예제 #4
0
파일: ai.cpp 프로젝트: mutnig/vdrift
void AI::Visualize()
{
#ifdef VISUALIZE_AI_DEBUG
	/*if (!AI_Cars.empty())
		Visualize(&AI_Cars.back(), topnode);*/
	for ( std::vector<AI_Car>::iterator it = AI_Cars.begin (); it != AI_Cars.end (); it++ )
	{
		Visualize(&(*it));
	}
#endif
}
// ============================================================================
int ML_Epetra::MultiLevelPreconditioner::
VisualizeAggregates()
{
  bool viz = List_.get("viz: enable",false);
  if (viz) {
    if (IsPreconditionerComputed() == false)
      ML_CHK_ERR(-1); // need an already computed preconditioner

    ML_CHK_ERR(Visualize(true, false, false, false, -1, -1, -1));

  }
  return(0);
}
예제 #6
0
파일: runsvs.cpp 프로젝트: rizar/svs
int App::Run() {
    Load();
    if (ParamsInputPath_.size()) {
        Params_.Load(ParamsInputPath_.c_str());
    }

    Builder_.SetParams(Params_);
    Builder_.SetInputCloud(Input_);
    PrintParameters();

    Builder_.GenerateTrainingSet();
    ExportForLibSVM();

    if (AlphaInputPath_.size()) {
        std::ifstream alphaInput(AlphaInputPath_.c_str());
        std::vector<SVMFloat> alphas;
        std::copy(std::istream_iterator<SVMFloat>(alphaInput), std::istream_iterator<SVMFloat>(),
                std::back_inserter(alphas));

        Builder_.InitSVM(alphas);
    } else {
        Builder_.Learn();
        TrainedModel_ = true;
    }
    if (AlphaOutputPath_.size()) {
        std::ofstream alphaOutput(AlphaOutputPath_.c_str());
        std::copy(Builder_.SVM().Alphas(), Builder_.SVM().Alphas() + Builder_.Objects->size(),
                std::ostream_iterator<SVMFloat>(alphaOutput, "\n"));
    }
    if (ParamsOutputPath_.size()) {
        Params_.Save(ParamsOutputPath_.c_str());
    }
    ExportAlphaMap();

    Builder_.CalcGradients();

    PrintStatistics();
    Visualize();
    return 0;
}
// ============================================================================
int ML_Epetra::MultiLevelPreconditioner::
VisualizeCycle(int NumCycles)
{

  bool viz = List_.get("viz: enable",false);
  if (viz) {
    if (IsPreconditionerComputed() == false)
      ML_CHK_ERR(-1); // need an already computed preconditioner

    int ierr = Visualize(false, false, false, true,
               -1, -1, NumCycles);

    ML_CHK_ERR(ierr);
  }
  else
  {
    cout << PrintMsg_ << "You need to specify `viz: enable' = true" << endl;
    cout << PrintMsg_ << "in the parameter list before building the ML" << endl;
    cout << PrintMsg_ << "preconditioner in order to visualize" << endl;
    ML_CHK_ERR(-1);
  }
  return(0);
}
예제 #8
0
파일: serial.cpp 프로젝트: vjanjic/Projects
int main(int argc, char *argv[])
{
#ifdef PARSEC_VERSION
#define __PARSEC_STRING(x) #x
#define __PARSEC_XSTRING(x) __PARSEC_STRING(x)
        std::cout << "PARSEC Benchmark Suite Version "__PARSEC_XSTRING(PARSEC_VERSION) << std::endl << std::flush;
#else
        std::cout << "PARSEC Benchmark Suite" << std::endl << std::flush;
#endif //PARSEC_VERSION
#ifdef ENABLE_PARSEC_HOOKS
  __parsec_bench_begin(__parsec_fluidanimate);
#endif

  if(argc < 4 || argc >= 6)
  {
    std::cout << "Usage: " << argv[0] << " <threadnum> <framenum> <.fluid input file> [.fluid output file]" << std::endl;
    return -1;
  }

  int threadnum = atoi(argv[1]);
  int framenum = atoi(argv[2]);

  //Check arguments
  if(threadnum != 1) {
    std::cerr << "<threadnum> must be 1 (serial version)" << std::endl;
    return -1;
  }
  if(framenum < 1) {
    std::cerr << "<framenum> must at least be 1" << std::endl;
    return -1;
  }

#ifdef ENABLE_CFL_CHECK
  std::cout << "WARNING: Check for Courant–Friedrichs–Lewy condition enabled. Do not use for performance measurements." << std::endl;
#endif

  InitSim(argv[3]);
#ifdef ENABLE_VISUALIZATION
  InitVisualizationMode(&argc, argv, &AdvanceFrame, &numCells, &cells, &cnumPars);
#endif

#ifndef ENABLE_VISUALIZATION

//core of benchmark program (the Region-of-Interest)
#ifdef ENABLE_PARSEC_HOOKS
  __parsec_roi_begin();
#endif
  for(int i = 0; i < framenum; ++i) {
    AdvanceFrame();
  }
#ifdef ENABLE_PARSEC_HOOKS
  __parsec_roi_end();
#endif

#else //ENABLE_VISUALIZATION
  Visualize();
#endif //ENABLE_VISUALIZATION

  if(argc > 4)
    SaveFile(argv[4]);
  CleanUpSim();

#ifdef ENABLE_PARSEC_HOOKS
  __parsec_bench_end();
#endif

  return 0;
}