Merge pull request #2209 from SCIInstitute/matlab-warnings

Move Matlab warnings to verbose mode

Author: dcwhite

src/Core/IEPlugin/MatlabFiles_Plugin.cc

@@ -225,7 +225,7 @@ SCIRun::MatlabField_reader(LoggerHandle pr, const char *filename)
       // Get the header of the object
       matlabarray ma = mf.getmatlabarrayinfo(p);
       // Is this object compatible?
-      if (mc.sciFieldCompatible(ma,dummytext))
+      if (mc.sciFieldCompatible(ma, dummytext, false))
       {
         // If so get the full object
         ma = mf.getmatlabarray(p);

src/Core/Matlab/matlabconverter.cc

@@ -44,13 +44,12 @@
 #include <Core/Datatypes/Legacy/Field/VMesh.h>
 #include <Core/Datatypes/Legacy/Field/VField.h>
 #include <Core/Datatypes/MatrixTypeConversions.h>
-#include <boost/assign/std/vector.hpp>
+#include <Core/Logging/Log.h>
 
 using namespace SCIRun;
 using namespace SCIRun::MatlabIO;
 using namespace SCIRun::Core::Logging;
 using namespace SCIRun::Core::Datatypes;
-using namespace boost::assign;
 
 // Currently the property converter only manages strings
 // all other data is ignored both on Matlab side as well
@@ -161,8 +160,8 @@ matlabarray::mitype matlabconverter::convertnrrdtype(int type)
 
 bool matlabconverter::isvalidmatrixname(const std::string& name)
 {
-  const std::string validchar("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_");
-  const std::string validstartchar("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
+  static const std::string validchar("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_");
+  static const std::string validstartchar("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
 
   bool valid = true;
   bool foundchar = false;
@@ -186,167 +185,12 @@ bool matlabconverter::isvalidmatrixname(const std::string& name)
         if (name[p] == validchar[q]) { foundchar = true; break; }
       }
     }
-    if (foundchar == false) { valid = false; break; }
+    if (!foundchar) { valid = false; break; }
   }
   return(valid);
 }
 
 #ifdef SCIRUN4_CODE_TO_BE_ENABLED_LATER
-void matlabconverter::mlPropertyTOsciProperty(matlabarray &ma,PropertyManager *handle)
-{
-  int numfields;
-  matlabarray::mlclass mclass;
-  matlabarray subarray;
-  std::string propname;
-  std::string propval;
-  matlabarray proparray;
-
-  std::string dummyinfo;
-  int matrixscore;
-  int fieldscore;
-
-  NrrdDataHandle  nrrd;
-  MatrixHandle    matrix;
-  FieldHandle     field;
-
-  // properties are stored in field property
-  int propindex = ma.getfieldnameindexCI("property");
-
-  if (propindex > -1)
-  { // field property exists
-
-    proparray = ma.getfield(0,propindex);
-    if (proparray.isempty()) return;
-
-    numfields = proparray.getnumfields();
-
-    for (int p=0; p<numfields; p++)
-    {
-      subarray = proparray.getfield(0,p);
-      mclass = subarray.getclass();
-
-      // Check whether property is string
-      // In the property manager string are STL strings
-      if (mclass == matlabarray::mlSTRING)
-      {   // only string arrays are converted
-        propname = proparray.getfieldname(p);
-        propval = subarray.getstring();
-        handle->set_property(propname,propval,false);
-        continue;
-      }
-
-      if ((fieldscore = sciFieldCompatible(subarray,dummyinfo)))
-      {
-        if (fieldscore > 1)
-        {
-           propname = proparray.getfieldname(p);
-           mlArrayTOsciField(subarray,field);
-           handle->set_property(propname,field,false);
-           continue;
-        }
-      }
-
-      if ((matrixscore = sciMatrixCompatible(subarray,dummyinfo)))
-      {
-        if (matrixscore > 1)
-        {
-           propname = proparray.getfieldname(p);
-           mlArrayTOsciMatrix(subarray,matrix);
-           handle->set_property(propname,matrix,false);
-           continue;
-        }
-        else
-        {
-          if (sciNrrdDataCompatible(subarray,dummyinfo))
-          {
-            propname = proparray.getfieldname(p);
-            mlArrayTOsciNrrdData(subarray,nrrd);
-            handle->set_property(propname,nrrd,false);
-            continue;
-          }
-          propname = proparray.getfieldname(p);
-          mlArrayTOsciMatrix(subarray,matrix);
-          handle->set_property(propname,matrix,false);
-          continue;
-        }
-      }
-
-      if (sciNrrdDataCompatible(subarray,dummyinfo))
-      {
-        propname = proparray.getfieldname(p);
-        mlArrayTOsciNrrdData(subarray,nrrd);
-        handle->set_property(propname,nrrd,false);
-        continue;
-      }
-      if (fieldscore > 0)
-      {
-        propname = proparray.getfieldname(p);
-        mlArrayTOsciField(subarray,field);
-        handle->set_property(propname,field,false);
-        continue;
-      }
-    }
-  }
-}
-
-void matlabconverter::sciPropertyTOmlProperty(PropertyManager *handle,matlabarray &ma)
-{
-  size_t numfields;
-  matlabarray proparray;
-  std::string propname;
-  std::string propvalue;
-  matlabarray subarray;
-
-  StringHandle    str;
-  MatrixHandle    matrix;
-  NrrdDataHandle  nrrd;
-  FieldHandle     field;
-
-  proparray.createstructarray();
-  numfields = handle->nproperties();
-
-  for (size_t p=0;p<numfields;p++)
-  {
-    propname = handle->get_property_name(p);
-    if (handle->get_property(propname,propvalue))
-    {
-      subarray.createstringarray(propvalue);
-      proparray.setfield(0,propname,subarray);
-    }
-    if (handle->get_property(propname,nrrd))
-    {
-      subarray.clear();
-      bool oldnumericarray_ = numericarray_;
-      numericarray_ = true;
-      sciNrrdDataTOmlArray(nrrd,subarray);
-      numericarray_ = oldnumericarray_;
-      proparray.setfield(0,propname,subarray);
-    }
-    if (handle->get_property(propname,matrix))
-    {
-      subarray.clear();
-      bool oldnumericarray_ = numericarray_;
-      numericarray_ = true;
-      sciMatrixTOmlArray(matrix,subarray);
-      numericarray_ = oldnumericarray_;
-      proparray.setfield(0,propname,subarray);
-    }
-    if (handle->get_property(propname,field))
-    {
-      subarray.clear();
-      sciFieldTOmlArray(field,subarray);
-      proparray.setfield(0,propname,subarray);
-    }
-    if (handle->get_property(propname,str))
-    {
-      subarray.clear();
-      sciStringTOmlArray(str,subarray);
-      proparray.setfield(0,propname,subarray);
-    }
-  }
-  ma.setfield(0,"property",proparray);
-}
-
 int matlabconverter::sciColorMapCompatible(matlabarray &ma, std::string &infotext, bool postremark)
 {
   infotext = "";
@@ -465,15 +309,17 @@ int matlabconverter::sciMatrixCompatible(const matlabarray &ma, std::string &inf
       if (index == -1) index = ma.getfieldnameindexCI("tensorfield");
       if (index == -1)
       {
-        if (postremark) remark(std::string("Matrix '" + ma.getname() + "' cannot be translated into a SCIRun Matrix (cannot find a field with data: create a .data field)."));
+        if (postremark)
+          SCIRun::logWarning("Matlab object '{}' cannot be translated into a SCIRun Field (cannot find a field with data: create a .data field).", ma.getname());
         return(0); // incompatible
       }
 
       int numel;
       numel = ma.getnumelements();
       if (numel > 1)
       {
-        if (postremark) remark(std::string("Matrix '" + ma.getname() + "' cannot be translated into a SCIRun Matrix (the struct matrix is not 1x1: do not define more than one matrix)."));
+        if (postremark)
+          remark(std::string("Matrix '" + ma.getname() + "' cannot be translated into a SCIRun Matrix (the struct matrix is not 1x1: do not define more than one matrix)."));
         return(0); // incompatible
       }
 
@@ -1442,8 +1288,8 @@ void matlabconverter::sciNrrdDataTOmlArray(NrrdDataHandle scinrrd, matlabarray &
   mlarray.setfield(0,"data",matrix);
 
   // Set the properties of the axis
-  std::vector<std::string> axisfieldnames;
-  axisfieldnames += "size", "spacing", "min", "max", "center", "label", "unit";
+  const std::vector<std::string> axisfieldnames =
+    {"size", "spacing", "min", "max", "center", "label", "unit"};
 
   Nrrd  *nrrdptr;
   nrrdptr = scinrrd->getNrrd();
@@ -1453,7 +1299,7 @@ void matlabconverter::sciNrrdDataTOmlArray(NrrdDataHandle scinrrd, matlabarray &
   dims[0] = nrrdptr->dim;
   dims[1] = 1;
 
-  axisma.createstructarray(dims,axisfieldnames);
+  axisma.createstructarray(dims, axisfieldnames);
 
   for (int p=0; p<static_cast<int>(nrrdptr->dim); p++ )
   {
@@ -1531,11 +1377,11 @@ void matlabconverter::sciNrrdDataTOmlArray(NrrdDataHandle scinrrd, matlabarray &
 //   LatVolMesh
 //   any suggestions for other types that need support ??
 
-int matlabconverter::sciFieldCompatible(const matlabarray& mlarray,std::string &infostring, bool postremark)
+int matlabconverter::sciFieldCompatible(const matlabarray& mlarray, std::string& infostring, bool postremark)
 {
   MatlabToFieldAlgo algo;
   algo.setreporter(pr_);
-  return(algo.analyze_iscompatible(mlarray,infostring,postremark));
+  return algo.analyze_iscompatible(mlarray, infostring, postremark);
 }
 
 void matlabconverter::mlArrayTOsciField(const matlabarray& mlarray, FieldHandle &scifield)
@@ -1708,18 +1554,18 @@ int matlabconverter::sciBundleCompatible(matlabarray &mlarray, std::string &info
   for (int p = 0; p < nfields; p++)
   {
     subarray = mlarray.getfield(0,p);
-    if (sciStringCompatible(subarray,dummyinfo,false)) { numstrings++; continue; }
+    if (sciStringCompatible(subarray, dummyinfo, false)) { numstrings++; continue; }
     if (prefer_bundles)  {if (sciBundleCompatible(subarray,dummyinfo,false)) { numbundles++; continue; } }
-    int score = sciFieldCompatible(subarray,dummyinfo,false);
+    int score = sciFieldCompatible(subarray, dummyinfo, false);
     if (prefer_fields)
       if (score > 0)  { numfields++; continue; }
     else
       if (score > 1)  { numfields++; continue; }
-    if (prefer_nrrds) { if (sciNrrdDataCompatible(subarray,dummyinfo,false))   { numnrrds++; continue; } }
+    if (prefer_nrrds) { if (sciNrrdDataCompatible(subarray, dummyinfo, false))   { numnrrds++; continue; } }
     if (sciMatrixCompatible(subarray,dummyinfo,false)) { nummatrices++; continue; }
-    if (!prefer_nrrds) { if (sciNrrdDataCompatible(subarray,dummyinfo,false))   { numnrrds++; continue; } }
+    if (!prefer_nrrds) { if (sciNrrdDataCompatible(subarray, dummyinfo, false))   { numnrrds++; continue; } }
     if (score) { numfields++; continue; }
-    if (sciBundleCompatible(subarray,dummyinfo,false)) { numbundles++; continue; }
+    if (sciBundleCompatible(subarray, dummyinfo, false)) { numbundles++; continue; }
   }
 
   if (numfields+nummatrices+numnrrds+numbundles+numstrings == 0)
@@ -1795,7 +1641,7 @@ void matlabconverter::mlArrayTOsciBundle(matlabarray &mlarray,BundleHandle &scib
       }
     }
 
-    int score = sciFieldCompatible(subarray,dummyinfo,false);
+    int score = sciFieldCompatible(subarray, dummyinfo, false);
     if (score > 1)
     {
       FieldHandle field;

src/Core/Matlab/matlabtofield.cc

@@ -38,6 +38,7 @@
 #include <Core/Datatypes/Legacy/Field/VMesh.h>
 #include <Core/Datatypes/Legacy/Field/FieldInformation.h>
 #include <Core/Logging/LoggerInterface.h>
+#include <Core/Logging/Log.h>
 #include <Core/Matlab/matlabconverter.h>
 
 using namespace SCIRun;
@@ -391,7 +392,8 @@ int MatlabToFieldAlgo::analyze_iscompatible(const matlabarray& mlarray, std::str
   }
   catch (matlabconverter::error_type& e)
   {
-    std::cerr << "analyze_fieldtype error: " << e.what() << std::endl;
+    if (postremark || Core::Logging::LogSettings::Instance().verbose())
+      SCIRun::logWarning("analyze_fieldtype error: {}", e.what());
     return 0;
   }
 
@@ -442,7 +444,8 @@ int MatlabToFieldAlgo::analyze_fieldtype(const matlabarray& mlarray, std::string
   }
   catch (matlabconverter::error_type& e)
   {
-    std::cerr << "analyze_fieldtype error: " << e.what() << std::endl;
+    if (Core::Logging::LogSettings::Instance().verbose())
+      logError("analyze_fieldtype error: {}", e.what());
     return 0;
   }
 

src/Modules/Legacy/Matlab/DataIO/ImportFieldsFromMatlab.cc

@@ -97,7 +97,7 @@ DatatypeHandle ImportFieldsFromMatlab::processMatlabData(const matlabarray& ma)
 
 int ImportFieldsFromMatlab::indexMatlabFile(matlabconverter& converter, const matlabarray& mlarray, std::string& infostring) const
 {
-  return converter.sciFieldCompatible(mlarray, infostring);
+  return converter.sciFieldCompatible(mlarray, infostring, Core::Logging::LogSettings::Instance().verbose());
 }
 
 void MatlabFileIndexModule::executeImpl(const StringPortName<0>& filenameIn, const StringPortName<6>& filenameOut)

src/Modules/Legacy/Matlab/DataIO/ImportMatricesFromMatlab.cc

@@ -92,5 +92,5 @@ DatatypeHandle ImportMatricesFromMatlab::processMatlabData(const matlabarray& ma
 
 int ImportMatricesFromMatlab::indexMatlabFile(matlabconverter& converter, const matlabarray& mlarray, std::string& infostring) const
 {
-  return converter.sciMatrixCompatible(mlarray, infostring);
+  return converter.sciMatrixCompatible(mlarray, infostring, Core::Logging::LogSettings::Instance().verbose());
 }