Merge remote-tracking branch 'SCIInstitute/master'

Author: allywarner

src/Core/Algorithms/Legacy/Fields/MarchingCubes/MarchingCubes.cc

@@ -6,7 +6,7 @@
    Copyright (c) 2009 Scientific Computing and Imaging Institute,
    University of Utah.
 
-   
+
    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
@@ -90,73 +90,73 @@ template <class TESSELATOR>
 class MarchingCubesAlgoP {
 
   public:
-  
-    MarchingCubesAlgoP(FieldHandle input,const std::vector<double>& iso_values) : 
+
+    MarchingCubesAlgoP(FieldHandle input,const std::vector<double>& iso_values) :
      input_(input),
      iso_values_(iso_values) { }
-    
+
     ~MarchingCubesAlgoP()
     {
       #ifdef SCIRUN4_CODE_TO_BE_ENABLED_LATER
        delete_all_items(tesselator_);
       #endif
     }
-    
+
     FieldHandle    input_;
-         
+
     std::vector<TESSELATOR*>   tesselator_;
     std::vector<FieldHandle>  output_field_;
     std::vector<MatrixHandle> output_interpolant_matrix_;
     std::vector<MatrixHandle> output_parent_cell_matrix_;
     #ifdef SCIRUN4_CODE_TO_BE_ENABLED_LATER
      std::vector<GeomHandle>   output_geometry_;
     #endif
-    
+
     bool build_field_;
     bool build_node_interpolant_;
     bool build_elem_interpolant_;
     bool build_geometry_;
     bool transparency_;
-    
+
     const std::vector<double>& iso_values_;
     const AlgorithmBase* algo_;
-    
+
     bool run(const AlgorithmBase* algo, FieldHandle& output,
              MatrixHandle& node_interpolant,MatrixHandle& elem_interpolant );
-             
+
     void parallel(int proc, int nproc, size_t iso);
-    
+
   private:
     AppendFieldsAlgorithm append_fields_;
     AppendMatrixAlgorithm append_matrices_;
 
 };
 
 
-bool 
-MarchingCubesAlgo::run(FieldHandle input, std::vector<double>& isovalues)
+bool
+MarchingCubesAlgo::run(FieldHandle input, const std::vector<double>& isovalues)
 {
   FieldHandle dummy0;
   MatrixHandle dummy1, dummy2;
   return run(input,isovalues,dummy0,dummy1,dummy2);
 }
 
-bool 
-MarchingCubesAlgo::run(FieldHandle input, std::vector<double>& isovalues, FieldHandle& field )
+bool
+MarchingCubesAlgo::run(FieldHandle input, const std::vector<double>& isovalues, FieldHandle& field )
 {
   MatrixHandle dummy1, dummy2;
   return run(input,isovalues,field,dummy1,dummy2);
 }
 
 template <class TESSELATOR>
 bool
-MarchingCubesAlgoP<TESSELATOR>::run(const AlgorithmBase* algo, 
-                        FieldHandle& output, 
+MarchingCubesAlgoP<TESSELATOR>::run(const AlgorithmBase* algo,
+                        FieldHandle& output,
                         MatrixHandle& node_interpolant,
-                        MatrixHandle& elem_interpolant) 
+                        MatrixHandle& elem_interpolant)
 {
   algo_ = algo;
-  
+
  #ifdef SCIRUN4_CODE_TO_BE_ENABLED_LATER
   int np = algo->get_int("num_threads");
   /// By default (-1) choose number of processors
@@ -165,47 +165,47 @@ MarchingCubesAlgoP<TESSELATOR>::run(const AlgorithmBase* algo,
   if (np > 4*Thread::numProcessors()) np = 4*Thread::numProcessors();
   */
   /// @todo: FIX MULTI THREADING OF MARCHING CUBES FIELDS ARE NOT PROPORLY LINKED
- #endif 
+ #endif
   int np = Parallel::NumCores();
-  
+
   np = 1;
   size_t num_values = iso_values_.size();
-  
+
   tesselator_.resize(np);
   for (size_t j=0; j<tesselator_.size(); j++)
     tesselator_[j] = new TESSELATOR(input_);
-  
+
   output_field_.resize(np*num_values);
   output_interpolant_matrix_.resize(np*num_values);
-  output_parent_cell_matrix_.resize(np*num_values);  
+  output_parent_cell_matrix_.resize(np*num_values);
   //output_geometry_.resize(np*num_values);
-  
+
   build_field_ = algo->get(MarchingCubesAlgo::build_field).toBool();
   build_geometry_ = algo->get(MarchingCubesAlgo::build_geometry).toBool();
   build_node_interpolant_ = algo->get(MarchingCubesAlgo::build_node_interpolant).toBool();
   build_elem_interpolant_ = algo->get(MarchingCubesAlgo::build_elem_interpolant).toBool();
   transparency_ = algo->get(MarchingCubesAlgo::transparency).toBool();
-  
- #ifdef SCIRUN4_CODE_TO_BE_ENABLED_LATER 
+
+ #ifdef SCIRUN4_CODE_TO_BE_ENABLED_LATER
   append_fields_.set_progress_reporter(algo->get_progress_reporter());
   append_matrices_.set_progress_reporter(algo->get_progress_reporter());
   append_matrices_.setOption("method","append_rows");
  #endif
 
   for (size_t j=0; j<iso_values_.size(); j++)
   {
-    if (np == 1) 
+    if (np == 1)
     {
       parallel(0,1,j);
     }
     else
     {
-      #ifdef SCIRUN4_CODE_TO_BE_ENABLED_LATER 
+      #ifdef SCIRUN4_CODE_TO_BE_ENABLED_LATER
        Thread::parallel(this,&MarchingCubesAlgoP<TESSELATOR>::parallel,np,np,j);
       #endif
     }
   }
-  #ifdef SCIRUN4_CODE_TO_BE_ENABLED_LATER  
+  #ifdef SCIRUN4_CODE_TO_BE_ENABLED_LATER
   if (output_geometry_.size() == 0)
   {
     geometry = 0;
@@ -219,45 +219,45 @@ MarchingCubesAlgoP<TESSELATOR>::run(const AlgorithmBase* algo,
     // link geometries
     GeomGroup* group = new GeomGroup;
     for (size_t j=0; j < output_geometry_.size(); j++) group->add(output_geometry_[j]);
-    geometry = group; 
+    geometry = group;
   }
  #endif
- 
+
   if (build_field_)
   {
-   if (!(append_fields_.run(output_field_,output))) 
+   if (!(append_fields_.run(output_field_,output)))
       return (false);
   }
 
  #ifdef SCIRUN4_CODE_TO_BE_ENABLED_LATER
   if (build_node_interpolant_)
   {
-    if (!(append_matrices_.run(output_interpolant_matrix_,node_interpolant))) 
+    if (!(append_matrices_.run(output_interpolant_matrix_,node_interpolant)))
       return (false);
   }
 
   if (build_elem_interpolant_)
   {
-    if (!(append_matrices_.run(output_parent_cell_matrix_,elem_interpolant))) 
+    if (!(append_matrices_.run(output_parent_cell_matrix_,elem_interpolant)))
       return (false);
   }
  #endif
- 
+
   return (true);
 }
 
-bool MarchingCubesAlgo::run(FieldHandle input, std::vector<double>& isovalues, FieldHandle& field, MatrixHandle& node_interpolant, MatrixHandle& elem_interpolant) const
+bool MarchingCubesAlgo::run(FieldHandle input, const std::vector<double>& isovalues, FieldHandle& field, MatrixHandle& node_interpolant, MatrixHandle& elem_interpolant) const
 {
 
   if (!input)
   {
      error("MarchingCube algorithm error: Input field is Null pointer.");
   }
-  
+
   bool success = false;
-  
+
   FieldInformation fi(input);
-  
+
   if (fi.is_pnt_element())
   {
     error("Field needs to have elements in order to  extract isosurfaces");
@@ -300,7 +300,7 @@ bool MarchingCubesAlgo::run(FieldHandle input, std::vector<double>& isovalues, F
       success = algo.run(this,field,node_interpolant,elem_interpolant);
     }
   }
-  
+
   return true;
 }
 
@@ -311,21 +311,21 @@ void MarchingCubesAlgoP<TESSELATOR>::parallel( int proc, int nproc, size_t iso)
   tesselator_[proc]->reset(0, build_field_, build_geometry_, transparency_);
 
   VMesh*  imesh  = input_->vmesh();
-  
-  VMesh::size_type num_elems = imesh->num_elems(); 
-  
+
+  VMesh::size_type num_elems = imesh->num_elems();
+
   index_type start = (proc)*(num_elems/nproc);
   index_type end = (proc < nproc-1) ? (proc+1)*(num_elems/nproc) : num_elems;
 
   index_type cnt = 0;
   size_type total = (num_elems*iso_values_.size()/nproc);
-  index_type offset = (num_elems*iso/nproc); 
+  index_type offset = (num_elems*iso/nproc);
   double isoval = iso_values_[iso];
 
   for(VMesh::Elem::index_type idx= start ; idx<end; idx++)
   {
     tesselator_[proc]->extract(idx, isoval);
-    if (proc == 0)  
+    if (proc == 0)
     {
       cnt++;
       if (cnt == 300)
@@ -335,17 +335,17 @@ void MarchingCubesAlgoP<TESSELATOR>::parallel( int proc, int nproc, size_t iso)
       }
     }
   }
-  
+
   output_field_[iso*nproc+proc] = 0;
   output_interpolant_matrix_[iso*nproc+proc] = 0;
   output_parent_cell_matrix_[iso*nproc+proc] = 0;
-  
+
   #ifdef SCIRUN4_CODE_TO_BE_ENABLED_LATER
    output_geometry_[iso*nproc+proc] = 0;
   #endif
-  
-  if (build_field_) 
-  { 
+
+  if (build_field_)
+  {
     output_field_[iso*nproc+proc] = tesselator_[proc]->get_field(isoval);
   }
   if (build_node_interpolant_)
@@ -356,7 +356,7 @@ void MarchingCubesAlgoP<TESSELATOR>::parallel( int proc, int nproc, size_t iso)
   {
     output_parent_cell_matrix_[iso*nproc+proc] = tesselator_[proc]->get_parent_cells();
   }
-  
+
   #ifdef SCIRUN4_CODE_TO_BE_ENABLED_LATER
   if (build_geometry_)
   {
@@ -383,6 +383,5 @@ void MarchingCubesAlgoP<TESSELATOR>::parallel( int proc, int nproc, size_t iso)
     }
   }
   #endif
-  
-}
 
+}

src/Core/Algorithms/Legacy/Fields/MarchingCubes/MarchingCubes.h

@@ -6,7 +6,7 @@
    Copyright (c) 2015 Scientific Computing and Imaging Institute,
    University of Utah.
 
-   
+
    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
@@ -48,43 +48,43 @@
 namespace SCIRun {
  namespace Core {
   namespace Algorithms {
-  
-   class SCISHARE MarchingCubesAlgo : public AlgorithmBase 
+
+   class SCISHARE MarchingCubesAlgo : public AlgorithmBase
    {
 
     public:
 
     MarchingCubesAlgo();
-    
+
     static AlgorithmParameterName transparency;
     static AlgorithmParameterName build_geometry;
     static AlgorithmParameterName build_field;
     static AlgorithmParameterName build_node_interpolant;
     static AlgorithmParameterName build_elem_interpolant;
     static AlgorithmParameterName num_threads;
-   
+
    #ifdef SCIRUN4_CODE_TO_BE_ENABLED_LATER
-   {  
+   {
       add_color("color",Color(0.5,0.5,0.5));
       add_colormap("colormap",0);
     };
     #endif
-    
-    bool run(FieldHandle input, std::vector<double>& isovalues);
-   
-    bool run(FieldHandle input, std::vector<double>& isovalues, FieldHandle& field);
-     
-    bool run(FieldHandle input, std::vector<double>& isovalues, 
+
+    bool run(FieldHandle input, const std::vector<double>& isovalues);
+
+    bool run(FieldHandle input, const std::vector<double>& isovalues, FieldHandle& field);
+
+    bool run(FieldHandle input, const std::vector<double>& isovalues,
              FieldHandle& field, Datatypes::MatrixHandle& interpolant );
-	     
+
     AlgorithmOutput run(const AlgorithmInput& input) const;
-    
-    bool run(FieldHandle input, std::vector<double>& isovalues, 
+
+    bool run(FieldHandle input, const std::vector<double>& isovalues,
              FieldHandle& field,
              Datatypes::MatrixHandle& node_interpolant,
              Datatypes::MatrixHandle& elem_interpolant ) const;
    };
-  
+
   }
  } // End namespace SCIRun
 }