Merge branch 'SCIInstitute/master'

Author: allywarner

.travis.yml

@@ -35,7 +35,7 @@ install:
 script:
   cd bin
   && cmake -DDOWNLOAD_TOOLKITS:BOOL=OFF -DRUN_BASIC_REGRESSION_TESTS:BOOL=OFF ../src
-  && make -j8
+  && make -j4
   && make SCIRunTestData_external
 #  && make test
 

src/CMakeLists.txt

@@ -144,7 +144,8 @@ SET(APPLICATION_EXTENSION ".srn5" CACHE INTERNAL "Network file extension" FORCE)
 SET(APPLICATION_URL "www.scirun.org" CACHE INTERNAL "Project URL" FORCE)
 SET(APPLICATION_VENDOR "SCI" CACHE INTERNAL "Vendor information" FORCE)
 SET(APPLICATION_CONTACT "[email protected]" CACHE INTERNAL "Contact information" FORCE)
-SET(APPLICATION_WINDOWS_ICON "${CMAKE_SOURCE_DIR}/Interface/Application\\\\scirun-icon-large.ico" CACHE INTERNAL "Windows icon" FORCE)
+SET(APPLICATION_WINDOWS_ICON "${CMAKE_SOURCE_DIR}/Resources/Icons\\\\scirun5_32.ico" CACHE INTERNAL "Windows icon" FORCE)
+SET(APPLICATION_WINDOWS_RC "${CMAKE_SOURCE_DIR}/Resources/Icons\\\\SCIRun.rc" CACHE INTERNAL "Windows icon" FORCE)
 SET(APPLICATION_OSX_ICON_FULL_PATH "${CMAKE_SOURCE_DIR}/Resources/Icons/scirun5.icns" CACHE INTERNAL "OSX icon" FORCE)
 SET(APPLICATION_OSX_ICON "scirun5.icns" CACHE INTERNAL "OSX icon" FORCE)
 
@@ -783,6 +784,7 @@ SET_PROPERTY(TARGET Modules_Legacy_Visualization   PROPERTY FOLDER "Modules/Visu
 SET_PROPERTY(TARGET Modules_Factory   PROPERTY FOLDER "Modules")
 
 SET_PROPERTY(TARGET Graphics_Glyphs   PROPERTY FOLDER "Graphics")
+SET_PROPERTY(TARGET Graphics_Widgets   PROPERTY FOLDER "Graphics")
 
 IF(BUILD_TESTING)
   SET_PROPERTY(TARGET gmock         PROPERTY FOLDER "Testing Support")
@@ -840,6 +842,8 @@ IF(BUILD_TESTING)
   SET_PROPERTY(TARGET Modules_Visualization_Tests   PROPERTY FOLDER "Modules/Visualization")
   SET_PROPERTY(TARGET Modules_Legacy_Matlab_DataIO_Tests PROPERTY FOLDER "Modules/DataIO")
   SET_PROPERTY(TARGET Modules_Factory_Tests   PROPERTY FOLDER "Modules/Basic")
+  
+  SET_PROPERTY(TARGET Interface_Modules_Render_Tests PROPERTY FOLDER "Interface/Tests")
 ENDIF()
 
 SET_PROPERTY(TARGET Boost_external   PROPERTY FOLDER "Externals")
@@ -864,6 +868,7 @@ ENDIF()
 
 IF(DOWNLOAD_TOOLKITS)
   SET_PROPERTY(TARGET BrainStimulator_external   PROPERTY FOLDER "Externals")
+  SET_PROPERTY(TARGET FwdInvToolkit_external   PROPERTY FOLDER "Externals")
 ENDIF()
 
 ########################################################################

src/Core/Algorithms/BrainStimulator/ElectrodeCoilSetupAlgorithm.cc

@@ -62,6 +62,10 @@ namespace BrainStimulator {
   ALGORITHM_PARAMETER_DECL(NumberOfPrototypes);
   ALGORITHM_PARAMETER_DECL(ElectrodethicknessCheckBox);
   ALGORITHM_PARAMETER_DECL(ElectrodethicknessSpinBox);
+  ALGORITHM_PARAMETER_DECL(InvertNormalsCheckBox);
+  ALGORITHM_PARAMETER_DECL(OrientTMSCoilRadialToScalpCheckBox);
+  ALGORITHM_PARAMETER_DECL(PutElectrodesOnScalpCheckBox);
+  ALGORITHM_PARAMETER_DECL(InterpolateElectrodeShapeCheckbox);
 
   class SCISHARE ElectrodeCoilSetupAlgorithm : public AlgorithmBase
   {
@@ -90,7 +94,7 @@ namespace BrainStimulator {
     Datatypes::DenseMatrixHandle make_rotation_matrix(const double angle, const std::vector<double>& normal) const;
     boost::tuple<Datatypes::DenseMatrixHandle, FieldHandle, FieldHandle, VariableHandle> make_tdcs_electrodes(FieldHandle scalp, const std::vector<FieldHandle>& elc_coil_proto,
     const std::vector<double>& elc_prototyp_map, const std::vector<double>& elc_x, const std::vector<double>& elc_y, const std::vector<double>& elc_z, const std::vector<double>& elc_angle_rotation, const std::vector<double>& elc_thickness, VariableHandle table) const;            
-    FieldHandle make_tms(FieldHandle scalp, const std::vector<FieldHandle>& elc_coil_proto, const std::vector<double>& coil_prototyp_map, const std::vector<double>& coil_x, const std::vector<double>& coil_y, const std::vector<double>& coil_z, const std::vector<double>& coil_angle_rotation, const std::vector<double>& coil_nx, const std::vector<double>& coil_ny, const std::vector<double>& coil_nz) const;        
+    FieldHandle make_tms(FieldHandle scalp, const std::vector<FieldHandle>& elc_coil_proto, const std::vector<double>& coil_prototyp_map, const std::vector<double>& coil_x, const std::vector<double>& coil_y, const std::vector<double>& coil_z, const std::vector<double>& coil_angle_rotation, std::vector<double>& coil_nx, std::vector<double>& coil_ny, std::vector<double>& coil_nz) const;        
     VariableHandle fill_table(FieldHandle scalp, Datatypes::DenseMatrixHandle locations, const std::vector<FieldHandle>& input) const;
     boost::tuple<Variable::List, double, double, double> make_table_row(int i,double x, double y, double z, double nx, double ny, double nz) const;
   };

src/Core/Algorithms/BrainStimulator/ElectrodeCoilSetupAlgorithm.h

@@ -207,15 +207,14 @@ boost::tuple<DenseMatrixHandle, DenseMatrixHandle, DenseMatrixHandle, DenseMatri
  {
   THROW_ALGORITHM_PROCESSING_ERROR(" The scalp surface (second module input, field, SCALP_TRI_SURF_MESH) must be a triangle mesh. "); 
  } 
-  
+
  VMesh*  mesh_vmesh = mesh->vmesh();
  VMesh::size_type mesh_num_nodes = mesh_vmesh->num_nodes();
  mesh_vmesh->synchronize(Mesh::NODE_LOCATE_E);
  DenseMatrixHandle lhs_knows, elc_elem, elc_elem_typ, elc_elem_def, elc_con_imp;
  std::vector<double> electrode_sponge_areas;
  index_type refnode_number = get(Parameters::refnode).toInt();
  bool getsurf = get(Parameters::GetContactSurface).toBool();
- 
  double normal_dot_product_bound_ = get(Parameters::normal_dot_product_bound).toDouble();
  double identical_node_location_differce = get(Parameters::pointdistancebound).toDouble();
 
@@ -280,7 +279,7 @@ boost::tuple<DenseMatrixHandle, DenseMatrixHandle, DenseMatrixHandle, DenseMatri
  algo.set(SplitFieldByConnectedRegionAlgo::SortDomainBySize(), false);
  algo.set(SplitFieldByConnectedRegionAlgo::SortAscending(), false);
  std::vector<FieldHandle> result = algo.run(elc_tri_surf);
- 
+
  if (result.size()<=0)
  {
     THROW_ALGORITHM_PROCESSING_ERROR(" Splitting input mesh into connected regions failed. ");
@@ -311,14 +310,15 @@ boost::tuple<DenseMatrixHandle, DenseMatrixHandle, DenseMatrixHandle, DenseMatri
  VMesh* elc_sponge_surf_vmesh = elc_sponge_surf->vmesh();  
  VField* elc_sponge_surf_vfld  = elc_sponge_surf->vfield();
  std::vector<double> field_values, impedances;
- 
+
  /// map the electrode sponge center (CreateElectrodeCoil) to generated tDCS electrode geometry (Cleaver), 
  /// this mapping is meant to map the GUI inputs to actual electrode geometry by having a lookup table
  int electrode_sponges=elc_sponge_location->nrows();
  DenseMatrixHandle lookup(new DenseMatrix(electrode_sponges, 1));
  DenseMatrixHandle distances(new DenseMatrix(electrode_sponges, 1));
  VMesh::Node::index_type didx;
  double distance=0; 
+
  for (long i=0;i<electrode_sponges;i++)
  {
   Point elc((*elc_sponge_location)(i,0),(*elc_sponge_location)(i,1),(*elc_sponge_location)(i,2)),r;
@@ -330,6 +330,7 @@ boost::tuple<DenseMatrixHandle, DenseMatrixHandle, DenseMatrixHandle, DenseMatri
    tmp_mesh->synchronize(Mesh::NODE_LOCATE_E); 
 
    tmp_mesh->find_closest_node(distance,r,didx,elc);
+   
    if (distance<min_dis)
    {
      min_dis=distance;
@@ -339,7 +340,7 @@ boost::tuple<DenseMatrixHandle, DenseMatrixHandle, DenseMatrixHandle, DenseMatri
   (*lookup)(i,0)=found_index;
   (*distances)(i,0)=min_dis;
  }
- 
+
  /// throw error if the geometry is too far away from predicted location - further away than sponge thickness
  for (long i=0;i<elc_sponge_location->nrows();i++)
  {
@@ -365,7 +366,6 @@ boost::tuple<DenseMatrixHandle, DenseMatrixHandle, DenseMatrixHandle, DenseMatri
  DenseMatrixHandle sponge_center_pojected_onto_scalp(new DenseMatrix(result.size(), 3));
 
  mesh_scalp_tri_surf->synchronize(Mesh::NODE_LOCATE_E);
-
  for(long i=0;i<result.size();i++)
  {
   VMesh*  tmp_mesh = result[i]->vmesh();
@@ -408,7 +408,6 @@ boost::tuple<DenseMatrixHandle, DenseMatrixHandle, DenseMatrixHandle, DenseMatri
   mesh_scalp_tri_surf->find_closest_node(distance,p,node_ind,q);
   (*sponge_center_pojected_onto_scalp_index)(i,0)=node_ind;
  }
- 
  /// determine normal of scalp/electrode sponge inferface center 
  mesh_scalp_tri_surf->synchronize(Mesh::NORMALS_E);
  VMesh::Elem::array_type ca;
@@ -432,11 +431,9 @@ boost::tuple<DenseMatrixHandle, DenseMatrixHandle, DenseMatrixHandle, DenseMatri
  mesh_elc_tri_surf->synchronize(Mesh::NODE_LOCATE_E); 
 
  int nr_elc_sponge_triangles=0;
-
  FieldInformation fi3("PointCloudMesh",0,"double");
  FieldHandle estimated_sponge_top_center_points=CreateField(fi3);
  VMesh*  estimated_sponge_top_center_points_vmesh = estimated_sponge_top_center_points->vmesh();
- 
  /// retrieve electrode thickness from last input by using the lookup table
  for(int k=0;k<sponge_center_pojected_onto_scalp_normal->nrows();k++)
  {
@@ -545,7 +542,6 @@ boost::tuple<DenseMatrixHandle, DenseMatrixHandle, DenseMatrixHandle, DenseMatri
 
   double dot_sp_o1 = Dot(sp_o1, current_scalp_normal_at_elec);
   double dot_sp_o2 = Dot(sp_o2, current_scalp_normal_at_elec);
-  
   double x=0,y=0,z=0;  
   if( (dot_sp_o1<0 && dot_sp_o2<0) || (dot_sp_o1>0 && dot_sp_o2>0) )
   {
@@ -716,7 +712,7 @@ boost::tuple<DenseMatrixHandle, DenseMatrixHandle, DenseMatrixHandle, DenseMatri
    THROW_ALGORITHM_PROCESSING_ERROR("Internal error: internal field definition is "); 
  }
 
- double area=0.0; double prev_elc=0;
+ double area=0.0,prev_elc=0,tmp_fld_val=0;
  for(VMesh::Elem::index_type l=0; l<elc_sponge_surf_vmesh->num_elems(); l++)
  {
   (*elc_elem_typ)(l,0)=2; //define triangles to incject currents in TDCS simulations
@@ -753,15 +749,14 @@ boost::tuple<DenseMatrixHandle, DenseMatrixHandle, DenseMatrixHandle, DenseMatri
   double x3=pos.x(), y3=pos.y(), z3=pos.z();
 
   (*elc_elem_def)(l,3)=0; 
-  (*elc_elem)(l,0)=field_values[l]; 
-  (*elc_con_imp)(l,0)=impedances[l];
+  (*elc_elem)(l,0)=field_values[l];   
 
   ///compute surface area of electrode/scalp interface
   double area_tmp =y1*z2+z1*y3+y2*z3-z2*y3-z1*y2-y1*z3;
   double area_tmp1=z1*x2+x1*z3+z2*x3-x2*z3-x1*z2-z1*x3;
   double area_tmp2=x1*y2+y1*x3+x2*y3-y2*x3-y1*x2-x1*y3;
   double triangle_area=0.5 * sqrt(area_tmp*area_tmp+area_tmp1*area_tmp1+area_tmp2*area_tmp2);
-  double tmp_fld_val=0;
+  tmp_fld_val=0;
   elc_sponge_surf_vfld->get_value(tmp_fld_val,l);
 
   if(prev_elc!=tmp_fld_val)
@@ -775,8 +770,21 @@ boost::tuple<DenseMatrixHandle, DenseMatrixHandle, DenseMatrixHandle, DenseMatri
    area+=triangle_area;
   }
  }
+ 
  area*=1e-6;
+ 
  electrode_sponge_areas.push_back(area);
+ 
+ for(VMesh::Elem::index_type l=0; l<elc_sponge_surf_vmesh->num_elems(); l++) /// the impedance (Ohm * m^2) that was provided by the user needs to be defined related to the electrode area. For convenience we do that for the user here.
+ {
+  elc_sponge_surf_vfld->get_value(tmp_fld_val,l);
+  if(tmp_fld_val>=electrode_sponge_areas.size())
+   { 
+    THROW_ALGORITHM_PROCESSING_ERROR("Internal ERROR (should not happen): could not scale contact impedance by electrode surface area (index out of bound). "); 
+   }
+   (*elc_con_imp)(l,0)=impedances[tmp_fld_val]*electrode_sponge_areas[tmp_fld_val];
+ }
+ 
  DenseMatrixHandle selectmatrixind(new DenseMatrix(mesh_vmesh->num_nodes(), 1)); ///create indeces for SelectSubMatrix
  for(long i=0;i<mesh_vmesh->num_nodes();i++)
  { 
@@ -802,7 +810,7 @@ DenseMatrixHandle SetupTDCSAlgorithm::create_rhs(FieldHandle mesh, FieldHandle e
     double temp = elcs_wanted[i].toDouble();
     min_current += temp;
   }
-  
+
   if (std::fabs(min_current) > electode_current_summation_bound) 
         THROW_ALGORITHM_INPUT_ERROR("Summed electrode current intensities are greater than 1e-6 mA. The sum should be close to 0 mA !!! ");  
 
@@ -815,7 +823,11 @@ DenseMatrixHandle SetupTDCSAlgorithm::create_rhs(FieldHandle mesh, FieldHandle e
   VMesh* mesh_elc_tri_surf = elc_tri_surf->vmesh();
   mesh_elc_tri_surf->synchronize(Mesh::NODE_LOCATE_E); 
   vmesh->synchronize(Mesh::NODE_LOCATE_E); 
-  
+  for(VMesh::Node::index_type l=0; l<vmesh->num_nodes(); l++)
+  {
+    (*output)(l,0)=0;
+  }
+  double min_dis = get(Parameters::pointdistancebound).toDouble();
   for(VMesh::Node::index_type l=0; l<mesh_elc_tri_surf->num_nodes(); l++)
   {
    Point p,q; 
@@ -824,8 +836,14 @@ DenseMatrixHandle SetupTDCSAlgorithm::create_rhs(FieldHandle mesh, FieldHandle e
    VMesh::Node::index_type ind;
    vmesh->find_closest_node(distance,q,ind,p);
    (*output)(ind,0)=elcs_wanted[l].toDouble()/1000.0;
+   if(min_dis<distance)
+   {
+     std::ostringstream ostr4;
+     ostr4 << " The electrode locations (4th module input) are further away from them mesh as provided by the GUI (min. distance bound). " << std::endl;
+     remark(ostr4.str());	
+   }
   } 
-    
+
   return output;
  } else
  { 
@@ -859,14 +877,12 @@ boost::tuple<DenseMatrixHandle, DenseMatrixHandle, DenseMatrixHandle, DenseMatri
 {
   if (num_of_elc > max_number_of_electrodes) { THROW_ALGORITHM_INPUT_ERROR("Number of electrodes (>512) given exceeds what is possible ");}  /// number of  possible electrodes is currently bound to 512 electrodes in default setting
   if (num_of_elc < 0) { THROW_ALGORITHM_INPUT_ERROR("Negative number of electrodes given ");}
-  
   if (!mesh) THROW_ALGORITHM_INPUT_ERROR("Input field (mesh) was not allocated "); 
   if (!scalp_tri_surf) THROW_ALGORITHM_INPUT_ERROR("Input field (scalp triangle surface) was not allocated ");
   if (!elc_tri_surf) THROW_ALGORITHM_INPUT_ERROR("Input field (electrode triangle surface) was not allocated ");
   if (!elc_sponge_location) THROW_ALGORITHM_INPUT_ERROR("Input field (electrode triangle surface) was not allocated ");
-  
   DenseMatrixHandle rhs=create_rhs(mesh, elc_tri_surf, elcs, num_of_elc); /// get the right-hand-side
-  
+
   DenseMatrixHandle lhs_knowns, elc_element, elc_element_typ, elc_element_def, elc_contact_imp, selectmatrixind;
   FieldHandle elec_sponge_surf;
   std::vector<double> electrode_sponge_areas;

src/Core/Algorithms/BrainStimulator/SetupRHSforTDCSandTMSAlgorithm.cc

@@ -82,10 +82,9 @@ namespace BrainStimulator {
 
     static Core::Algorithms::AlgorithmParameterName ElectrodeParameterName(int i);
     static Core::Algorithms::AlgorithmParameterName ElectrodeImpedanceParameterName(int i);
-   
+    static const int max_number_of_electrodes;
   private:  
     static const int special_label;
-    static const int max_number_of_electrodes;
     static const double electode_current_summation_bound;
     SCIRun::Core::Datatypes::DenseMatrixHandle create_rhs(FieldHandle mesh, FieldHandle elc_tri_surf, const std::vector<Variable>& elcs, int num_of_elc) const;    
     boost::tuple<Datatypes::DenseMatrixHandle, Datatypes::DenseMatrixHandle, Datatypes::DenseMatrixHandle, Datatypes::DenseMatrixHandle, Datatypes::DenseMatrixHandle, Datatypes::DenseMatrixHandle, FieldHandle, std::vector<double>> create_lhs(FieldHandle mesh, const std::vector<Variable>& impelc, FieldHandle scalp_tri_surf, FieldHandle elc_tri_surf, SCIRun::Core::Datatypes::DenseMatrixHandle elc_sponge_location) const;

src/Core/Algorithms/BrainStimulator/SetupRHSforTDCSandTMSAlgorithm.h

@@ -33,16 +33,82 @@
 #include <Core/Algorithms/Base/AlgorithmPreconditions.h>
 #include <Core/Algorithms/BrainStimulator/ElectrodeCoilSetupAlgorithm.h>
 #include <Testing/Utils/SCIRunUnitTests.h>
-//////////////////////////////////////////////////////////////////////////
-/// @todo MORITZ
-//////////////////////////////////////////////////////////////////////////
+#include <Testing/Utils/MatrixTestUtilities.h>
+#include <boost/lexical_cast.hpp>
+#include <boost/range/algorithm/count.hpp>
+#include <boost/algorithm/string/trim.hpp>
+#include <boost/algorithm/string/split.hpp>
+#include <boost/algorithm/string/classification.hpp>
+#include <boost/format.hpp>
+#include <boost/assign.hpp>
+#include <vector>
+#include <iostream>
+#include <Core/Math/MiscMath.h>
+
 using namespace SCIRun;
 using namespace SCIRun::Core::Geometry;
+using namespace SCIRun::Core::Datatypes;
 using namespace SCIRun::Core::Algorithms::BrainStimulator;
+using namespace SCIRun::Core::Algorithms;
 using namespace SCIRun::TestUtils;
+using namespace boost;
+using namespace boost::assign;
 
-TEST(ElectrodeCoilSetupAlgorithm, DISABLED_Foo)
+namespace
+{
+  FieldHandle LoadMickeyScalpSurfMeshForAlgo()
+  {
+    return loadFieldFromFile(TestResources::rootDir() / "Fields/BrainStim/micky_scalp.fld");
+  }
+  FieldHandle LoadMickeyTMSCoilForAlgo()
+  {
+    return loadFieldFromFile(TestResources::rootDir() / "Fields/BrainStim/mickey_tms_coil.fld");
+  }
+    
+  DenseMatrixHandle TMSCoilLocationForAlgo()
+  { 
+   DenseMatrixHandle m(boost::make_shared<DenseMatrix>(1,3));
+   (*m)(0,0) = 33.6654;
+   (*m)(0,1) = 34.625;
+   (*m)(0,2) = 10.6;
+
+   return m;
+  }
+}
+
+
+TEST(ElectrodeCoilSetupAlgorithmTests, AlgoCorrect)
 {
   ElectrodeCoilSetupAlgorithm algo;
-  FAIL() << "Insert code here for the most basic test cases !"; 
+  FieldHandle coils_field,electrodes_field, final_electrode_field;
+  FieldHandle scalp=LoadMickeyScalpSurfMeshForAlgo();
+  Variable::List table;
+  DenseMatrixHandle elc_sponge_loc_avr, locations=TMSCoilLocationForAlgo();
+  std::vector<FieldHandle> elc_coil_proto;
+  elc_coil_proto.push_back(LoadMickeyTMSCoilForAlgo());
+  Variable var1,var2,var3,var4,var5,var6,var7,var8,var9,var10;
+  var1=makeVariable("Input #", boost::str(boost::format("%s") % "USE_MODULE_INPUT_3"));
+  var2=makeVariable("Type",   boost::str(boost::format("%s") % "TMS"));   
+  var3=makeVariable("X",     boost::str(boost::format("%.3f") % "33.6654"));
+  var4=makeVariable("Y",     boost::str(boost::format("%.3f") % "34.625"));
+  var5=makeVariable("Y",     boost::str(boost::format("%.3f") % "7.6"));
+  var6=makeVariable("Angle",  boost::str(boost::format("%s") % "1"));  
+  var7=makeVariable("NX", boost::str(boost::format("%s") % "???"));
+  var8=makeVariable("NY", boost::str(boost::format("%s") % "???"));
+  var9=makeVariable("NZ", boost::str(boost::format("%s") % "???"));
+  var10=makeVariable("thickness",boost::str(boost::format("%s") % "2"));
+  Variable::List tmp;
+  tmp += var1,var2,var3,var4,var5,var6,var7,var8,var9,var10;
+  table.push_back(makeVariable("row" + boost::lexical_cast<std::string>(0), tmp)); 
+  VariableHandle output(new Variable(Name("Table"), table));
+  ///@Dan: I dont know how to set the table to the GUI so that the module can executed properly.
+  
+ // boost::tie(table, elc_sponge_loc_avr, electrodes_field, final_electrode_field, coils_field) = algo.run(scalp, locations, elc_coil_proto);
+  /*
+  EXPECT_EQ(coils_field->vmesh()->num_nodes(),18);
+  EXPECT_EQ(coils_field->vmesh()->num_elems(),18);
+  EXPECT_EQ(coils_field->vfield()->num_values(),18);
+  //need more check routines here !!!
+  */
 }
+