Merge pull request #1701 from SCIInstitute/complex-calculations

Complex calculations et al

Author: dcwhite

src/Core/Algorithms/Describe/DescribeDatatype.cc

@@ -72,6 +72,15 @@ std::string DescribeDatatype::describe(const DatatypeHandle& data) const
     return "[Complex Matrix Data] Info:\n" + ReportComplexMatrixInfoAlgo::summarize(info);
   }
 
+  auto cmatsp = boost::dynamic_pointer_cast<ComplexSparseRowMatrix>(data);
+  if (cmatsp)
+  {
+    ReportComplexMatrixInfoAlgo algo;
+    auto info = algo.runImpl(cmatsp);
+
+    return "[Complex Matrix Data] Info:\n" + ReportComplexMatrixInfoAlgo::summarize(info);
+  }
+
   auto field = boost::dynamic_pointer_cast<Field>(data);
   if (field)
   {

src/Core/Algorithms/Describe/Tests/DescribeDatatypeTests.cc

@@ -32,6 +32,7 @@
 #include <Testing/Utils/MatrixTestUtilities.h>
 #include <Testing/Utils/SCIRunUnitTests.h>
 #include <Testing/ModuleTestBase/ModuleTestBase.h>
+#include <Core/Datatypes/MatrixTypeConversions.h>
 
 
 using namespace SCIRun;
@@ -70,3 +71,28 @@ TEST(DescribeDatatypeAlgorithmTests, CanDescribeField)
 
   EXPECT_EQ("[Field Data] Info:\nType: GenericField<LatVolMesh<HexTrilinearLgn<Point> > ,HexTrilinearLgn<double> ,FData3d<double,LatVolMesh<HexTrilinearLgn<Point> > > > \nCenter: [0 0 0]\nSize: [2 2 2]\nData min,max: 0 , 0\n# nodes: 60\n# elements: 24\n# data: 60\nData location: Nodes (linear basis)\nDims (x,y,z): [3 4 5]\nGeometric size: 8\n", desc);
 }
+
+TEST(DescribeDatatypeAlgorithmTests, CanDescribeComplexDenseMatrix)
+{
+  DescribeDatatype algo;
+
+  auto m = boost::make_shared<ComplexDenseMatrix>(2, 2);
+  *m << complex{ 1, 2 }, complex{ 3, -1 }, complex{ 0, 1 }, complex{ -2, -1 };
+
+  auto desc = algo.describe(m);
+
+  EXPECT_EQ("[Complex Matrix Data] Info:\nType:\t\tComplexDenseMatrix\n# Rows:\t\t2\n# Columns:\t\t2\n# Elements:\t\t4\nMinimum (by norm):\t(0,1)\nMaximum (by norm):\t(3,-1)\n", desc);
+}
+
+TEST(DescribeDatatypeAlgorithmTests, CanDescribeComplexSparseMatrix)
+{
+  DescribeDatatype algo;
+
+  ComplexDenseMatrix m(2, 2);
+  m << complex{ 1, 2 }, complex{ 3, -1 }, complex{ 0, 1 }, complex{ -2, -1 };
+  auto s = convertMatrix::fromDenseToSparse(m);
+
+  auto desc = algo.describe(s);
+
+  EXPECT_EQ("[Complex Matrix Data] Info:\nType:\t\tComplexSparseRowMatrix\n# Rows:\t\t2\n# Columns:\t\t2\n# Elements:\t\t4\nMinimum (by norm):\t(0,1)\nMaximum (by norm):\t(3,-1)\n", desc);
+}

src/Core/Algorithms/Legacy/Fields/FieldData/BuildMatrixOfSurfaceNormalsAlgo.cc

@@ -26,28 +26,21 @@
    DEALINGS IN THE SOFTWARE.
 */
 
-#include <Core/Algorithms/Legacy/Fields/FieldData/BuildMatrixOfSurfaceNormalsAlgo.h> 
+#include <Core/Algorithms/Legacy/Fields/FieldData/BuildMatrixOfSurfaceNormalsAlgo.h>
 #include <Core/Algorithms/Base/AlgorithmPreconditions.h>
 #include <Core/Algorithms/Base/AlgorithmVariableNames.h>
-//#include <Core/GeometryPrimitives/Vector.h>
 #include <Core/Datatypes/Legacy/Field/Field.h>
 #include <Core/Datatypes/Legacy/Field/VField.h>
-#include <Core/Datatypes/DenseMatrix.h> 
+#include <Core/Datatypes/DenseMatrix.h>
 #include <Core/GeometryPrimitives/Vector.h>
-#include <Core/Datatypes/Legacy/Matrix/Matrix.h> 
 #include <Core/Datatypes/Legacy/Field/FieldInformation.h> 
 
-//#include <Core/Datatypes/DenseMatrix.h> 
-//#include <Core/Datatypes/Legacy/Field/VMesh.h>
-
-//#include <iostream>
-
 using namespace SCIRun::Core::Algorithms;
 using namespace SCIRun::Core::Algorithms::Fields;
 using namespace SCIRun::Core::Datatypes;
 using namespace SCIRun::Core::Geometry;
-using namespace SCIRun::Core::Logging; 
-using namespace SCIRun::Core::Utility; 
+using namespace SCIRun::Core::Logging;
+using namespace SCIRun::Core::Utility;
 using namespace SCIRun;
 
 BuildMatrixOfSurfaceNormalsAlgo::BuildMatrixOfSurfaceNormalsAlgo() {}
@@ -61,19 +54,19 @@ bool BuildMatrixOfSurfaceNormalsAlgo::runImpl(FieldHandle input, DenseMatrixHand
     error("No input source field");
     return (false);
   }
-  
-  FieldInformation fi(input);  
+
+  FieldInformation fi(input);
   if (!(fi.is_surface()))
   {
     error("This algorithm only works on a surface mesh");
     return (false);
   }
-  
+
   VMesh* vmesh = input->vmesh();
   vmesh->synchronize(Mesh::NORMALS_E);
   VMesh::size_type num_nodes = vmesh->num_nodes();
 
-  output.reset(new DenseMatrix(num_nodes, 3)); 
+  output.reset(new DenseMatrix(num_nodes, 3));
 
   if (!output)
   {
@@ -86,10 +79,10 @@ bool BuildMatrixOfSurfaceNormalsAlgo::runImpl(FieldHandle input, DenseMatrixHand
   Vector norm;
   for (VMesh::Node::index_type i=0; i<num_nodes; ++i)
   {
-    vmesh->get_normal(norm,i); 
+    vmesh->get_normal(norm,i);
     (*output)(k) = norm.x();
 		(*output)(k+1) = norm.y();
-		(*output)(k+2) = norm.z(); 
+		(*output)(k+2) = norm.z();
     k += 3;
     cnt++; if (cnt == 400) {cnt=0; update_progress_max(i,num_nodes); }
   }
@@ -99,12 +92,12 @@ bool BuildMatrixOfSurfaceNormalsAlgo::runImpl(FieldHandle input, DenseMatrixHand
 AlgorithmOutput BuildMatrixOfSurfaceNormalsAlgo::run(const AlgorithmInput& input) const
 {
   auto field = input.get<Field>(Variables::InputField);
-	DenseMatrixHandle outputMatrix; 
+	DenseMatrixHandle outputMatrix;
 
 	if(!runImpl(field, outputMatrix))
-			THROW_ALGORITHM_PROCESSING_ERROR("False returned on legacy call."); 
+			THROW_ALGORITHM_PROCESSING_ERROR("False returned on legacy call.");
 
   AlgorithmOutput output;
   output[Variables::OutputMatrix] = outputMatrix;
   return output;
-}
+}

src/Core/Algorithms/Legacy/Fields/FieldData/SetFieldData.cc

@@ -399,7 +399,7 @@ FieldHandle SetFieldDataAlgo::runImplRealComplex(FieldHandle input_field, DenseM
     found = verify_input_data(input_field, realData->nrows(), realData->ncols(), numvals, fi);
   else if (complexData)
   {
-    found = verify_input_data(input_field, complexData->nrows(), complexData->ncols(), numvals, fi, "std::complex<double>");
+    found = verify_input_data(input_field, complexData->nrows(), complexData->ncols(), numvals, fi, "complex");
   }
 
   if (!found)

src/Core/Algorithms/Math/AppendMatrix.cc

@@ -24,7 +24,7 @@
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.
-   
+
    Author : Moritz Dannhauer (reimplementation)
    Date:   August 2017
 */
@@ -33,7 +33,6 @@
 #include <Core/Datatypes/DenseMatrix.h>
 #include <Core/Datatypes/SparseRowMatrix.h>
 #include <Core/Datatypes/SparseRowMatrixFromMap.h>
-#include <Core/Datatypes/Legacy/Matrix/MatrixOperations.h>
 #include <Core/Algorithms/Base/AlgorithmVariableNames.h>
 #include <Core/Datatypes/MatrixTypeConversions.h>
 #include <Eigen/Sparse>
@@ -58,16 +57,16 @@ bool AppendMatrixAlgorithm::check_dimensions(const Matrix& mat1, const Matrix& m
   if(cols_m1!=cols_m2) return false;
  } else
   if(rows_m1!=rows_m2) return false;
- 
+
  return true;
 }
 
 AppendMatrixAlgorithm::Outputs AppendMatrixAlgorithm::ConcatenateMatrices(const MatrixHandle base_matrix, const std::vector<boost::shared_ptr<Matrix>> input_matrices, const AppendMatrixAlgorithm::Parameters& params) const
-{  
+{
 
  if (input_matrices.size()==0)
    return base_matrix;
-   
+
  Outputs outputs = run(boost::make_tuple(base_matrix, input_matrices[0]), params);
  for(Eigen::Index c=1; c<input_matrices.size(); c++)
  {
@@ -79,49 +78,49 @@ AppendMatrixAlgorithm::Outputs AppendMatrixAlgorithm::ConcatenateMatrices(const
 }
 
 AppendMatrixAlgorithm::Outputs AppendMatrixAlgorithm::run(const AppendMatrixAlgorithm::Inputs& input, const AppendMatrixAlgorithm::Parameters& params) const
-{ 
+{
   auto lhsPtr = input.get<0>();
   auto rhsPtr = input.get<1>();
   if (!lhsPtr || !rhsPtr)
    error(" At least two matrices are needed to run this module. ");
 
-  if (!((matrixIs::sparse(lhsPtr) && matrixIs::sparse(rhsPtr)) || (matrixIs::dense(lhsPtr) && matrixIs::dense(rhsPtr)) || (matrixIs::column(lhsPtr) && matrixIs::column(rhsPtr))))  
+  if (!((matrixIs::sparse(lhsPtr) && matrixIs::sparse(rhsPtr)) || (matrixIs::dense(lhsPtr) && matrixIs::dense(rhsPtr)) || (matrixIs::column(lhsPtr) && matrixIs::column(rhsPtr))))
   {
    error(" Mixing of different matrix types as inputs is not supported. ");
-   return Outputs(); 
+   return Outputs();
   }
-  
+
   if (!check_dimensions(*lhsPtr, *rhsPtr, params))
   {
     error(" Input matrix dimensions do not match. ");
     return Outputs();
   }
-  
+
   Eigen::MatrixXd result;
   if(matrixIs::dense(lhsPtr) || matrixIs::column(lhsPtr))
   {
    if(params == ROWS)
      result=Eigen::MatrixXd(lhsPtr->nrows()+rhsPtr->nrows(),lhsPtr->ncols());
     else
-     result=Eigen::MatrixXd(lhsPtr->nrows(),lhsPtr->ncols()+rhsPtr->ncols());  
-   
+     result=Eigen::MatrixXd(lhsPtr->nrows(),lhsPtr->ncols()+rhsPtr->ncols());
+
    if(matrixIs::dense(lhsPtr))
      result << *castMatrix::toDense(lhsPtr), *castMatrix::toDense(rhsPtr);
    else
     result << *castMatrix::toColumn(lhsPtr), *castMatrix::toColumn(rhsPtr);
- 
+
    if (matrixIs::column(lhsPtr) && (result.rows()==1 || result.cols()==1))
-    return boost::make_shared<DenseColumnMatrix>(result); 
-    
+    return boost::make_shared<DenseColumnMatrix>(result);
+
    return boost::make_shared<DenseMatrix>(result);
   } else
   if (matrixIs::sparse(lhsPtr))
     return SparseRowMatrixFromMap::concatenateSparseMatrices(*castMatrix::toSparse(lhsPtr),*castMatrix::toSparse(rhsPtr),params==ROWS);
   else
   {
    error(" This matrix type is not supported");
-  } 
- 
+  }
+
  return Outputs();
 }
 
@@ -130,14 +129,14 @@ AlgorithmOutput AppendMatrixAlgorithm::run(const AlgorithmInput& input) const
   auto lhs = input.get<Matrix>(Variables::FirstMatrix);
   auto rhs = input.get<Matrix>(Variables::SecondMatrix);
   auto input_matrices = input.getList<Matrix>(AppendMatrixAlgorithm::InputMatrices);
-  
-  Outputs outputs; 
+
+  Outputs outputs;
   Parameters params=Option(get(Variables::RowsOrColumns).toInt());
   outputs = run(boost::make_tuple(lhs, rhs), params);
- 
+
   if (input_matrices.size()>0)
    outputs = ConcatenateMatrices(outputs, input_matrices, params);
-    
+
   AlgorithmOutput output;
   output[Variables::ResultMatrix] = outputs;
   return output;

src/Core/Application/Preferences/Preferences.cc

@@ -32,6 +32,7 @@
 #include <boost/filesystem.hpp>
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/algorithm/string/split.hpp>
+#include <boost/algorithm/string/replace.hpp>
 #include <boost/algorithm/string/classification.hpp>
 #ifdef BUILD_WITH_PYTHON
 #include <Core/Python/PythonInterpreter.h>
@@ -90,7 +91,8 @@ void Preferences::setDataDirectory(const boost::filesystem::path& path, bool run
 #ifdef BUILD_WITH_PYTHON
   if (runPython)
   {
-    auto setDataDir = "import os; os.environ[\"SCIRUNDATADIR\"] = \"" + dataDir_.string() + "\"";
+    auto forwardSlashPath = boost::replace_all_copy(dataDir_.string(), "\\", "/");
+    auto setDataDir = "import os; os.environ[\"SCIRUNDATADIR\"] = \"" + forwardSlashPath + "\"";
     PythonInterpreter::Instance().run_string(setDataDir);
   }
 #endif

src/Core/Datatypes/Color.h

@@ -85,6 +85,16 @@ namespace Datatypes {
     std::tuple<int,int> windowSize;
   };
 
+  struct SCISHARE MeshComponentSelectionFeedback : ModuleFeedback
+  {
+    MeshComponentSelectionFeedback() {}
+    MeshComponentSelectionFeedback(const std::string& mod, const std::string& comp, bool sel) :
+      moduleId(mod), component(comp), selected(sel) {}
+    std::string moduleId;
+    std::string component;
+    bool selected {false};
+  };
+
 }}}
 
 

src/Core/Datatypes/DenseColumnMatrix.h

@@ -47,7 +47,7 @@ namespace Datatypes {
     typedef DenseColumnMatrixGeneric<T> this_type;
     typedef Eigen::Matrix<T, Eigen::Dynamic, 1> EigenBase;
 
-    DenseColumnMatrixGeneric(size_t nrows = 0) : EigenBase(nrows) {}
+    explicit DenseColumnMatrixGeneric(size_t nrows = 0) : EigenBase(nrows) {}
 
     /// This constructor allows you to construct DenseColumnMatrixGeneric from Eigen expressions
     template<typename OtherDerived>

src/Core/Datatypes/Geometry.h

@@ -61,7 +61,7 @@ namespace Datatypes
 
   struct SCISHARE ModuleFeedback
   {
-    // tag class
+    virtual ~ModuleFeedback() {}
   };
 
 }}}

src/Core/Datatypes/Legacy/Base/TypeName.cc

@@ -70,7 +70,7 @@ template<> std::string find_type_name(double*)
 
 template<> std::string find_type_name(std::complex<double>*)
 {
-  static const std::string name = "std::complex<double>";
+  static const std::string name = "complex";
   return name;
 }