Re #14613 Clang format

Framework/API/inc/MantidAPI/IMDNode.h

@@ -267,7 +267,8 @@ public:
   virtual signal_t getSignalWithMask() const = 0;
   virtual signal_t getSignalNormalizedWithMask() const = 0;
   virtual signal_t getSignalByNEventsWithMask() const {
-    return this->getSignalWithMask() / static_cast<signal_t>(this->getNPoints());
+    return this->getSignalWithMask() /
+           static_cast<signal_t>(this->getNPoints());
   }
 
   virtual void calcVolume() = 0;

Framework/DataObjects/inc/MantidDataObjects/MDBox.tcc

@@ -68,8 +68,8 @@ TMDE(MDBox)::MDBox(API::BoxController *const splitter, const uint32_t depth,
  */
 TMDE(MDBox)::MDBox(
     BoxController_sptr &splitter, const uint32_t depth,
-    const std::vector<
-        Mantid::Geometry::MDDimensionExtents<coord_t>> &extentsVector,
+    const std::vector<Mantid::Geometry::MDDimensionExtents<coord_t>> &
+        extentsVector,
     const size_t nBoxEvents, const size_t boxID)
     : MDBoxBase<MDE, nd>(splitter.get(), depth, boxID, extentsVector),
       m_Saveable(NULL), m_bIsMasked(false) {
@@ -86,8 +86,8 @@ TMDE(MDBox)::MDBox(
  */
 TMDE(MDBox)::MDBox(
     BoxController *const splitter, const uint32_t depth,
-    const std::vector<
-        Mantid::Geometry::MDDimensionExtents<coord_t>> &extentsVector,
+    const std::vector<Mantid::Geometry::MDDimensionExtents<coord_t>> &
+        extentsVector,
     const size_t nBoxEvents, const size_t boxID)
     : MDBoxBase<MDE, nd>(splitter, depth, boxID, extentsVector),
       m_Saveable(NULL), m_bIsMasked(false) {

Framework/DataObjects/inc/MantidDataObjects/MDBoxBase.tcc

@@ -21,8 +21,8 @@ TMDE(MDBoxBase)::MDBoxBase(Mantid::API::BoxController *const boxController,
       m_depth(depth), m_parent(NULL), m_fileID(boxID) {
   if (boxController) {
     // Give it a fresh ID from the controller.
-    if (boxID == std::numeric_limits<
-                     size_t>::max()) // Give it a fresh ID from the controller.
+    if (boxID == std::numeric_limits<size_t>::max()) // Give it a fresh ID from
+                                                     // the controller.
       this->m_fileID = boxController->getNextId();
   }
 }
@@ -32,8 +32,8 @@ TMDE(MDBoxBase)::MDBoxBase(Mantid::API::BoxController *const boxController,
 TMDE(MDBoxBase)::MDBoxBase(
     Mantid::API::BoxController *const boxController, const uint32_t depth,
     const size_t boxID,
-    const std::vector<
-        Mantid::Geometry::MDDimensionExtents<coord_t>> &extentsVector)
+    const std::vector<Mantid::Geometry::MDDimensionExtents<coord_t>> &
+        extentsVector)
     : m_signal(0.0), m_errorSquared(0.0), m_totalWeight(0.0),
       m_BoxController(boxController), m_inverseVolume(UNDEF_COORDT),
       m_depth(depth), m_parent(NULL), m_fileID(boxID) {

Vates/VatesAPI/inc/MantidVatesAPI/Normalization.h

@@ -17,8 +17,10 @@ class IMDEventWorkspace;
 namespace VATES {
 
 /** Enum describing different ways to normalize the signal
-* in a MDWorkspace. We define the VisualNormalization separate from the MDNormalization because from the
-visual perspective we want an AutoSelect option, which is too high level for the API MDNormalization and will cause
+* in a MDWorkspace. We define the VisualNormalization separate from the
+MDNormalization because from the
+visual perspective we want an AutoSelect option, which is too high level for the
+API MDNormalization and will cause
 confusion as to it's meaning if left in the core core.
 Do not change the enum integers. Adding new options to the enum is ok.
 */
@@ -29,7 +31,8 @@ enum VisualNormalization {
   VolumeNormalization = 1,
   /// Divide the signal by the number of events that contributed to it.
   NumEventsNormalization = 2,
-  /// Auto select Normalization. We ask the IMDWorkspace to tell us it's preference
+  /// Auto select Normalization. We ask the IMDWorkspace to tell us it's
+  /// preference
   AutoSelect = 3
 };
 
@@ -39,18 +42,18 @@ typedef Mantid::signal_t (Mantid::API::IMDNode::*NormFuncIMDNodePtr)() const;
 /**
 Determine which normalization function will be called on an IMDNode
 */
-NormFuncIMDNodePtr makeMDEventNormalizationFunction(
-    VisualNormalization normalizationOption,
-    Mantid::API::IMDEventWorkspace const *const ws,
-    const bool hasMask);
+NormFuncIMDNodePtr
+makeMDEventNormalizationFunction(VisualNormalization normalizationOption,
+                                 Mantid::API::IMDEventWorkspace const *const ws,
+                                 const bool hasMask);
 
 /**
-Determine which normalization function will be called on an IMDIterator of an IMDWorkspace
+Determine which normalization function will be called on an IMDIterator of an
+IMDWorkspace
 */
-DLLExport Mantid::API::IMDIterator * createIteratorWithNormalization(
-    const VisualNormalization normalizationOption,
-    Mantid::API::IMDWorkspace const * const ws);
-
+DLLExport Mantid::API::IMDIterator *
+createIteratorWithNormalization(const VisualNormalization normalizationOption,
+                                Mantid::API::IMDWorkspace const *const ws);
 }
 }
 

Vates/VatesAPI/src/Normalization.cpp

@@ -83,4 +83,4 @@ createIteratorWithNormalization(const VisualNormalization normalizationOption,
   return iterator;
 }
 }
-}
\ No newline at end of file
+}

Vates/VatesAPI/src/vtkMDLineFactory.cpp

@@ -17,195 +17,183 @@
 
 using namespace Mantid::API;
 
-namespace
-{
-  Mantid::Kernel::Logger g_log("vtkMDLineFactory");
+namespace {
+Mantid::Kernel::Logger g_log("vtkMDLineFactory");
 }
 
-namespace Mantid
-{
-  namespace VATES
-  {
-    /**
-    Constructor
-    @param thresholdRange : Thresholding range functor
-    @param normalizationOption : Normalization option to use
+namespace Mantid {
+namespace VATES {
+/**
+Constructor
+@param thresholdRange : Thresholding range functor
+@param normalizationOption : Normalization option to use
+*/
+vtkMDLineFactory::vtkMDLineFactory(
+    ThresholdRange_scptr thresholdRange,
+    const VisualNormalization normalizationOption)
+    : m_thresholdRange(thresholdRange),
+      m_normalizationOption(normalizationOption) {}
+
+/// Destructor
+vtkMDLineFactory::~vtkMDLineFactory() {}
+
+/**
+Create the vtkStructuredGrid from the provided workspace
+@param progressUpdating: Reporting object to pass progress information up the
+stack.
+@return fully constructed vtkDataSet.
+*/
+vtkDataSet *vtkMDLineFactory::create(ProgressAction &progressUpdating) const {
+  vtkDataSet *product = tryDelegatingCreation<IMDEventWorkspace, 1>(
+      m_workspace, progressUpdating);
+  if (product != NULL) {
+    return product;
+  } else {
+    g_log.warning() << "Factory " << this->getFactoryTypeName()
+                    << " is being used. You are viewing data with less than "
+                       "three dimensions in the VSI. \n";
+
+    IMDEventWorkspace_sptr imdws =
+        doInitialize<IMDEventWorkspace, 1>(m_workspace);
+    // Acquire a scoped read-only lock to the workspace (prevent segfault from
+    // algos modifying ws)
+    Mantid::Kernel::ReadLock lock(*imdws);
+
+    const size_t nDims = imdws->getNumDims();
+    size_t nNonIntegrated = imdws->getNonIntegratedDimensions().size();
+
+    /*
+    Write mask array with correct order for each internal dimension.
     */
-    vtkMDLineFactory::vtkMDLineFactory(ThresholdRange_scptr thresholdRange, const VisualNormalization normalizationOption) : m_thresholdRange(thresholdRange), m_normalizationOption(normalizationOption)
-    {
+    bool *masks = new bool[nDims];
+    for (size_t i_dim = 0; i_dim < nDims; ++i_dim) {
+      bool bIntegrated = imdws->getDimension(i_dim)->getIsIntegrated();
+      masks[i_dim] =
+          !bIntegrated; // TRUE for unmaksed, integrated dimensions are masked.
     }
 
-    /// Destructor
-    vtkMDLineFactory::~vtkMDLineFactory()
-    {
-    }
+    // Ensure destruction in any event.
+    boost::scoped_ptr<IMDIterator> it(
+        createIteratorWithNormalization(m_normalizationOption, imdws.get()));
 
-    /**
-    Create the vtkStructuredGrid from the provided workspace
-    @param progressUpdating: Reporting object to pass progress information up the stack.
-    @return fully constructed vtkDataSet.
-    */
-    vtkDataSet* vtkMDLineFactory::create(ProgressAction& progressUpdating) const
-    {
-      vtkDataSet* product = tryDelegatingCreation<IMDEventWorkspace, 1>(m_workspace, progressUpdating);
-      if(product != NULL)
-      {
-        return product;
-      }
-      else
-      {
-        g_log.warning() << "Factory " << this->getFactoryTypeName() << " is being used. You are viewing data with less than three dimensions in the VSI. \n";
-
-        IMDEventWorkspace_sptr imdws = doInitialize<IMDEventWorkspace, 1>(m_workspace);
-        // Acquire a scoped read-only lock to the workspace (prevent segfault from algos modifying ws)
-        Mantid::Kernel::ReadLock lock(*imdws);
-
-        const size_t nDims = imdws->getNumDims();
-        size_t nNonIntegrated = imdws->getNonIntegratedDimensions().size();
-
-        /*
-        Write mask array with correct order for each internal dimension.
-        */
-        bool* masks = new bool[nDims];
-        for(size_t i_dim = 0; i_dim < nDims; ++i_dim)
-        {
-          bool bIntegrated = imdws->getDimension(i_dim)->getIsIntegrated();
-          masks[i_dim] = !bIntegrated; //TRUE for unmaksed, integrated dimensions are masked.
-        }
-        
-        //Ensure destruction in any event.
-        boost::scoped_ptr<IMDIterator> it(createIteratorWithNormalization(m_normalizationOption, imdws.get()));
-
-        // Create 2 points per box.
-        vtkPoints *points = vtkPoints::New();
-        points->SetNumberOfPoints(it->getDataSize() * 2);
-
-        // One scalar per box
-        vtkFloatArray * signals = vtkFloatArray::New();
-        signals->Allocate(it->getDataSize());
-        signals->SetName(vtkDataSetFactory::ScalarName.c_str());
-        signals->SetNumberOfComponents(1);
-
-        size_t nVertexes;
-        
-        vtkUnstructuredGrid *visualDataSet = vtkUnstructuredGrid::New();
-        visualDataSet->Allocate(it->getDataSize());
-
-        vtkIdList * linePointList = vtkIdList::New();
-        linePointList->SetNumberOfIds(2);
-
-        Mantid::API::CoordTransform const* transform = NULL;
-        if (m_useTransform)
-        {
-          transform = imdws->getTransformToOriginal();
-        }
+    // Create 2 points per box.
+    vtkPoints *points = vtkPoints::New();
+    points->SetNumberOfPoints(it->getDataSize() * 2);
 
-        Mantid::coord_t out[1];
-        bool* useBox = new bool[it->getDataSize()];
-
-        double progressFactor = 0.5/double(it->getDataSize());
-        double progressOffset = 0.5;
-
-        size_t iBox = 0;
-        do
-        {
-          progressUpdating.eventRaised(double(iBox)*progressFactor);
-
-          Mantid::signal_t signal_normalized= it->getNormalizedSignalWithMask();
-          if (!isSpecial( signal_normalized ) && m_thresholdRange->inRange(signal_normalized))
-          {
-            useBox[iBox] = true;
-            signals->InsertNextValue(static_cast<float>(signal_normalized));
-
-            coord_t* coords = it->getVertexesArray(nVertexes, nNonIntegrated, masks);
-            delete [] coords;
-            coords = it->getVertexesArray(nVertexes, nNonIntegrated, masks);
-
-            //Iterate through all coordinates. Candidate for speed improvement.
-            for(size_t v = 0; v < nVertexes; ++v)
-            {
-              coord_t * coord = coords + v*1;
-              size_t id = iBox*2 + v;
-              if(m_useTransform)
-              {
-                transform->apply(coord, out);
-                points->SetPoint(id, out[0], 0, 0);
-              }
-              else
-              {
-                points->SetPoint(id, coord[0], 0, 0);
-              }
-            }
-            // Free memory
-            delete [] coords;
-          } // valid number of vertexes returned
-          else
-          {
-            useBox[iBox] = false;
-          }
-          ++iBox;
-        } while (it->next());
-
-        delete[] masks;
-        for(size_t ii = 0; ii < it->getDataSize() ; ++ii)
-        {
-          progressUpdating.eventRaised((double(ii)*progressFactor) + progressOffset);
-
-          if (useBox[ii] == true)
-          {
-            vtkIdType pointIds = ii * 2;
-
-            linePointList->SetId(0, pointIds + 0); //xyx
-            linePointList->SetId(1, pointIds + 1); //dxyz
-            visualDataSet->InsertNextCell(VTK_LINE, linePointList);
-          } // valid number of vertexes returned
-        }
+    // One scalar per box
+    vtkFloatArray *signals = vtkFloatArray::New();
+    signals->Allocate(it->getDataSize());
+    signals->SetName(vtkDataSetFactory::ScalarName.c_str());
+    signals->SetNumberOfComponents(1);
 
-        delete[] useBox;
+    size_t nVertexes;
 
-        signals->Squeeze();
-        points->Squeeze();
+    vtkUnstructuredGrid *visualDataSet = vtkUnstructuredGrid::New();
+    visualDataSet->Allocate(it->getDataSize());
 
-        visualDataSet->SetPoints(points);
-        visualDataSet->GetCellData()->SetScalars(signals);
-        visualDataSet->Squeeze();
+    vtkIdList *linePointList = vtkIdList::New();
+    linePointList->SetNumberOfIds(2);
 
-        signals->Delete();
-        points->Delete();
-        linePointList->Delete();
+    Mantid::API::CoordTransform const *transform = NULL;
+    if (m_useTransform) {
+      transform = imdws->getTransformToOriginal();
+    }
 
-        // Hedge against empty data sets
-        if (visualDataSet->GetNumberOfPoints() <= 0)
-        {
-          visualDataSet->Delete();
-          vtkNullUnstructuredGrid nullGrid;
-          visualDataSet = nullGrid.createNullData();
+    Mantid::coord_t out[1];
+    bool *useBox = new bool[it->getDataSize()];
+
+    double progressFactor = 0.5 / double(it->getDataSize());
+    double progressOffset = 0.5;
+
+    size_t iBox = 0;
+    do {
+      progressUpdating.eventRaised(double(iBox) * progressFactor);
+
+      Mantid::signal_t signal_normalized = it->getNormalizedSignalWithMask();
+      if (!isSpecial(signal_normalized) &&
+          m_thresholdRange->inRange(signal_normalized)) {
+        useBox[iBox] = true;
+        signals->InsertNextValue(static_cast<float>(signal_normalized));
+
+        coord_t *coords =
+            it->getVertexesArray(nVertexes, nNonIntegrated, masks);
+        delete[] coords;
+        coords = it->getVertexesArray(nVertexes, nNonIntegrated, masks);
+
+        // Iterate through all coordinates. Candidate for speed improvement.
+        for (size_t v = 0; v < nVertexes; ++v) {
+          coord_t *coord = coords + v * 1;
+          size_t id = iBox * 2 + v;
+          if (m_useTransform) {
+            transform->apply(coord, out);
+            points->SetPoint(id, out[0], 0, 0);
+          } else {
+            points->SetPoint(id, coord[0], 0, 0);
+          }
         }
-
-        return visualDataSet;
+        // Free memory
+        delete[] coords;
+      } // valid number of vertexes returned
+      else {
+        useBox[iBox] = false;
       }
-    }
+      ++iBox;
+    } while (it->next());
 
-    /// Initalize with a target workspace.
-    void vtkMDLineFactory::initialize(Mantid::API::Workspace_sptr ws)
-    {
-      m_workspace = doInitialize<IMDEventWorkspace, 1>(ws);
-    }
+    delete[] masks;
+    for (size_t ii = 0; ii < it->getDataSize(); ++ii) {
+      progressUpdating.eventRaised((double(ii) * progressFactor) +
+                                   progressOffset);
+
+      if (useBox[ii] == true) {
+        vtkIdType pointIds = ii * 2;
 
-    /// Get the name of the type.
-    std::string vtkMDLineFactory::getFactoryTypeName() const
-    {
-      return "vtkMDLineFactory";
+        linePointList->SetId(0, pointIds + 0); // xyx
+        linePointList->SetId(1, pointIds + 1); // dxyz
+        visualDataSet->InsertNextCell(VTK_LINE, linePointList);
+      } // valid number of vertexes returned
     }
 
-    /// Template Method pattern to validate the factory before use.
-    void vtkMDLineFactory::validate() const
-    {
-      if(NULL == m_workspace.get())
-      {
-        throw std::runtime_error("vtkMDLineFactory has no workspace to run against");
-      }
+    delete[] useBox;
+
+    signals->Squeeze();
+    points->Squeeze();
+
+    visualDataSet->SetPoints(points);
+    visualDataSet->GetCellData()->SetScalars(signals);
+    visualDataSet->Squeeze();
+
+    signals->Delete();
+    points->Delete();
+    linePointList->Delete();
+
+    // Hedge against empty data sets
+    if (visualDataSet->GetNumberOfPoints() <= 0) {
+      visualDataSet->Delete();
+      vtkNullUnstructuredGrid nullGrid;
+      visualDataSet = nullGrid.createNullData();
     }
 
+    return visualDataSet;
   }
 }
+
+/// Initalize with a target workspace.
+void vtkMDLineFactory::initialize(Mantid::API::Workspace_sptr ws) {
+  m_workspace = doInitialize<IMDEventWorkspace, 1>(ws);
+}
+
+/// Get the name of the type.
+std::string vtkMDLineFactory::getFactoryTypeName() const {
+  return "vtkMDLineFactory";
+}
+
+/// Template Method pattern to validate the factory before use.
+void vtkMDLineFactory::validate() const {
+  if (NULL == m_workspace.get()) {
+    throw std::runtime_error(
+        "vtkMDLineFactory has no workspace to run against");
+  }
+}
+}
+}

Vates/VatesAPI/src/vtkMDQuadFactory.cpp

@@ -17,193 +17,181 @@
 
 using namespace Mantid::API;
 
-namespace
-{
-  Mantid::Kernel::Logger g_log("vtkMDQuadFactory");
+namespace {
+Mantid::Kernel::Logger g_log("vtkMDQuadFactory");
 }
 
-namespace Mantid
-{
-  namespace VATES
-  {
-    /// Constructor
-    vtkMDQuadFactory::vtkMDQuadFactory(ThresholdRange_scptr thresholdRange, const VisualNormalization normalizationOption) : m_thresholdRange(thresholdRange), m_normalizationOption(normalizationOption)
-    {
-    }
-
-    /// Destructor
-    vtkMDQuadFactory::~vtkMDQuadFactory()
-    {
-    }
-
-    /**
-    Create the vtkStructuredGrid from the provided workspace
-    @param progressUpdating: Reporting object to pass progress information up the stack.
-    @return fully constructed vtkDataSet.
+namespace Mantid {
+namespace VATES {
+/// Constructor
+vtkMDQuadFactory::vtkMDQuadFactory(
+    ThresholdRange_scptr thresholdRange,
+    const VisualNormalization normalizationOption)
+    : m_thresholdRange(thresholdRange),
+      m_normalizationOption(normalizationOption) {}
+
+/// Destructor
+vtkMDQuadFactory::~vtkMDQuadFactory() {}
+
+/**
+Create the vtkStructuredGrid from the provided workspace
+@param progressUpdating: Reporting object to pass progress information up the
+stack.
+@return fully constructed vtkDataSet.
+*/
+vtkDataSet *vtkMDQuadFactory::create(ProgressAction &progressUpdating) const {
+  vtkDataSet *product = tryDelegatingCreation<IMDEventWorkspace, 2>(
+      m_workspace, progressUpdating);
+  if (product != NULL) {
+    return product;
+  } else {
+    g_log.warning() << "Factory " << this->getFactoryTypeName()
+                    << " is being used. You are viewing data with less than "
+                       "three dimensions in the VSI. \n";
+
+    IMDEventWorkspace_sptr imdws =
+        this->castAndCheck<IMDEventWorkspace, 2>(m_workspace);
+    // Acquire a scoped read-only lock to the workspace (prevent segfault from
+    // algos modifying ws)
+    Mantid::Kernel::ReadLock lock(*imdws);
+
+    const size_t nDims = imdws->getNumDims();
+    size_t nNonIntegrated = imdws->getNonIntegratedDimensions().size();
+
+    /*
+    Write mask array with correct order for each internal dimension.
     */
-    vtkDataSet* vtkMDQuadFactory::create(ProgressAction& progressUpdating) const
-    {
-      vtkDataSet* product = tryDelegatingCreation<IMDEventWorkspace, 2>(m_workspace, progressUpdating);
-      if(product != NULL)
-      {
-        return product;
-      }
-      else
-      {
-        g_log.warning() << "Factory " << this->getFactoryTypeName() << " is being used. You are viewing data with less than three dimensions in the VSI. \n";
-
-        IMDEventWorkspace_sptr imdws = this->castAndCheck<IMDEventWorkspace, 2>(m_workspace);
-        // Acquire a scoped read-only lock to the workspace (prevent segfault from algos modifying ws)
-        Mantid::Kernel::ReadLock lock(*imdws);
-
-        const size_t nDims = imdws->getNumDims();
-        size_t nNonIntegrated = imdws->getNonIntegratedDimensions().size();
-
-        /*
-        Write mask array with correct order for each internal dimension.
-        */
-        bool* masks = new bool[nDims];
-        for(size_t i_dim = 0; i_dim < nDims; ++i_dim)
-        {
-          bool bIntegrated = imdws->getDimension(i_dim)->getIsIntegrated();
-          masks[i_dim] = !bIntegrated; //TRUE for unmaksed, integrated dimensions are masked.
-        }
+    bool *masks = new bool[nDims];
+    for (size_t i_dim = 0; i_dim < nDims; ++i_dim) {
+      bool bIntegrated = imdws->getDimension(i_dim)->getIsIntegrated();
+      masks[i_dim] =
+          !bIntegrated; // TRUE for unmaksed, integrated dimensions are masked.
+    }
 
-        //Make iterator, which will use the desired normalization. Ensure destruction in any eventuality. 
-        boost::scoped_ptr<IMDIterator> it(createIteratorWithNormalization(m_normalizationOption, imdws.get()));
+    // Make iterator, which will use the desired normalization. Ensure
+    // destruction in any eventuality.
+    boost::scoped_ptr<IMDIterator> it(
+        createIteratorWithNormalization(m_normalizationOption, imdws.get()));
 
-        // Create 4 points per box.
-        vtkPoints *points = vtkPoints::New();
-        points->SetNumberOfPoints(it->getDataSize() * 4);
+    // Create 4 points per box.
+    vtkPoints *points = vtkPoints::New();
+    points->SetNumberOfPoints(it->getDataSize() * 4);
 
-        // One scalar per box
-        vtkFloatArray * signals = vtkFloatArray::New();
-        signals->Allocate(it->getDataSize());
-        signals->SetName(vtkDataSetFactory::ScalarName.c_str());
-        signals->SetNumberOfComponents(1);
+    // One scalar per box
+    vtkFloatArray *signals = vtkFloatArray::New();
+    signals->Allocate(it->getDataSize());
+    signals->SetName(vtkDataSetFactory::ScalarName.c_str());
+    signals->SetNumberOfComponents(1);
 
-        size_t nVertexes;
+    size_t nVertexes;
 
-        vtkUnstructuredGrid *visualDataSet = vtkUnstructuredGrid::New();
-        visualDataSet->Allocate(it->getDataSize());
+    vtkUnstructuredGrid *visualDataSet = vtkUnstructuredGrid::New();
+    visualDataSet->Allocate(it->getDataSize());
 
-        vtkIdList * quadPointList = vtkIdList::New();
-        quadPointList->SetNumberOfIds(4);
+    vtkIdList *quadPointList = vtkIdList::New();
+    quadPointList->SetNumberOfIds(4);
 
-        Mantid::API::CoordTransform const* transform = NULL;
-        if (m_useTransform)
-        {
-          transform = imdws->getTransformToOriginal();
-        }
+    Mantid::API::CoordTransform const *transform = NULL;
+    if (m_useTransform) {
+      transform = imdws->getTransformToOriginal();
+    }
 
-        Mantid::coord_t out[2];
-        bool* useBox = new bool[it->getDataSize()];
-
-        double progressFactor = 0.5/double(it->getDataSize());
-        double progressOffset = 0.5;
-
-        size_t iBox = 0;
-        do
-        {
-          progressUpdating.eventRaised(progressFactor * double(iBox));
-
-          Mantid::signal_t signal = it->getNormalizedSignalWithMask();
-          if (!isSpecial( signal ) && m_thresholdRange->inRange(signal))
-          {
-            useBox[iBox] = true;
-            signals->InsertNextValue(static_cast<float>(signal));
-
-            coord_t* coords = it->getVertexesArray(nVertexes, nNonIntegrated, masks);
-            delete [] coords;
-            coords = it->getVertexesArray(nVertexes, nNonIntegrated, masks);
-
-            //Iterate through all coordinates. Candidate for speed improvement.
-            for(size_t v = 0; v < nVertexes; ++v)
-            {
-              coord_t * coord = coords + v*2;
-              size_t id = iBox*4 + v;
-              if(m_useTransform)
-              {
-                transform->apply(coord, out);
-                points->SetPoint(id, out[0], out[1], 0);
-              }
-              else
-              {
-                points->SetPoint(id, coord[0], coord[1], 0);
-              }
-            }
-            // Free memory
-            delete [] coords;
-          } // valid number of vertexes returned
-          else
-          {
-            useBox[iBox] = false;
+    Mantid::coord_t out[2];
+    bool *useBox = new bool[it->getDataSize()];
+
+    double progressFactor = 0.5 / double(it->getDataSize());
+    double progressOffset = 0.5;
+
+    size_t iBox = 0;
+    do {
+      progressUpdating.eventRaised(progressFactor * double(iBox));
+
+      Mantid::signal_t signal = it->getNormalizedSignalWithMask();
+      if (!isSpecial(signal) && m_thresholdRange->inRange(signal)) {
+        useBox[iBox] = true;
+        signals->InsertNextValue(static_cast<float>(signal));
+
+        coord_t *coords =
+            it->getVertexesArray(nVertexes, nNonIntegrated, masks);
+        delete[] coords;
+        coords = it->getVertexesArray(nVertexes, nNonIntegrated, masks);
+
+        // Iterate through all coordinates. Candidate for speed improvement.
+        for (size_t v = 0; v < nVertexes; ++v) {
+          coord_t *coord = coords + v * 2;
+          size_t id = iBox * 4 + v;
+          if (m_useTransform) {
+            transform->apply(coord, out);
+            points->SetPoint(id, out[0], out[1], 0);
+          } else {
+            points->SetPoint(id, coord[0], coord[1], 0);
           }
-          ++iBox;
-        } while (it->next());
-
-        delete[] masks;
-        for(size_t ii = 0; ii < it->getDataSize() ; ++ii)
-        {
-          progressUpdating.eventRaised((progressFactor * double(ii)) + progressOffset);
-
-          if (useBox[ii] == true)
-          {
-            vtkIdType pointIds = vtkIdType(ii * 4);
-
-            quadPointList->SetId(0, pointIds + 0); //xyx
-            quadPointList->SetId(1, pointIds + 1); //dxyz
-            quadPointList->SetId(2, pointIds + 3); //dxdyz
-            quadPointList->SetId(3, pointIds + 2); //xdyz
-            visualDataSet->InsertNextCell(VTK_QUAD, quadPointList);
-          } // valid number of vertexes returned
         }
+        // Free memory
+        delete[] coords;
+      } // valid number of vertexes returned
+      else {
+        useBox[iBox] = false;
+      }
+      ++iBox;
+    } while (it->next());
+
+    delete[] masks;
+    for (size_t ii = 0; ii < it->getDataSize(); ++ii) {
+      progressUpdating.eventRaised((progressFactor * double(ii)) +
+                                   progressOffset);
+
+      if (useBox[ii] == true) {
+        vtkIdType pointIds = vtkIdType(ii * 4);
+
+        quadPointList->SetId(0, pointIds + 0); // xyx
+        quadPointList->SetId(1, pointIds + 1); // dxyz
+        quadPointList->SetId(2, pointIds + 3); // dxdyz
+        quadPointList->SetId(3, pointIds + 2); // xdyz
+        visualDataSet->InsertNextCell(VTK_QUAD, quadPointList);
+      } // valid number of vertexes returned
+    }
 
-        delete[] useBox;
-
-        signals->Squeeze();
-        points->Squeeze();
+    delete[] useBox;
 
-        visualDataSet->SetPoints(points);
-        visualDataSet->GetCellData()->SetScalars(signals);
-        visualDataSet->Squeeze();
+    signals->Squeeze();
+    points->Squeeze();
 
-        signals->Delete();
-        points->Delete();
-        quadPointList->Delete();
+    visualDataSet->SetPoints(points);
+    visualDataSet->GetCellData()->SetScalars(signals);
+    visualDataSet->Squeeze();
 
-        // Hedge against empty data sets
-        if (visualDataSet->GetNumberOfPoints() <= 0)
-        {
-          visualDataSet->Delete();
-          vtkNullUnstructuredGrid nullGrid;
-          visualDataSet = nullGrid.createNullData();
-        }
+    signals->Delete();
+    points->Delete();
+    quadPointList->Delete();
 
-        return visualDataSet;
-      }
+    // Hedge against empty data sets
+    if (visualDataSet->GetNumberOfPoints() <= 0) {
+      visualDataSet->Delete();
+      vtkNullUnstructuredGrid nullGrid;
+      visualDataSet = nullGrid.createNullData();
     }
 
-    /// Initalize with a target workspace.
-    void vtkMDQuadFactory::initialize(Mantid::API::Workspace_sptr ws)
-    {
-      m_workspace = doInitialize<IMDEventWorkspace, 2>(ws);
-    }
+    return visualDataSet;
+  }
+}
 
-    /// Get the name of the type.
-    std::string vtkMDQuadFactory::getFactoryTypeName() const
-    {
-      return "vtkMDQuadFactory";
-    }
+/// Initalize with a target workspace.
+void vtkMDQuadFactory::initialize(Mantid::API::Workspace_sptr ws) {
+  m_workspace = doInitialize<IMDEventWorkspace, 2>(ws);
+}
 
-    /// Template Method pattern to validate the factory before use.
-    void vtkMDQuadFactory::validate() const
-    {
-      if(NULL == m_workspace.get())
-      {
-        throw std::runtime_error("vtkMDQuadFactory has no workspace to run against");
-      }
-    }
+/// Get the name of the type.
+std::string vtkMDQuadFactory::getFactoryTypeName() const {
+  return "vtkMDQuadFactory";
+}
 
+/// Template Method pattern to validate the factory before use.
+void vtkMDQuadFactory::validate() const {
+  if (NULL == m_workspace.get()) {
+    throw std::runtime_error(
+        "vtkMDQuadFactory has no workspace to run against");
   }
 }
+}
+}

Vates/VatesAPI/test/vtkMDHWSignalArrayTest.h

@@ -105,7 +105,7 @@ public:
 
   void testLookupMaskedValues() {
     MDHistoWorkspace_sptr ws_sptr =
-      MDEventsTestHelper::makeFakeMDHistoWorkspace(1.0, 3, 4);
+        MDEventsTestHelper::makeFakeMDHistoWorkspace(1.0, 3, 4);
     vtkNew<vtkMDHWSignalArray<double>> signal;
     std::size_t offset = 0;
     const int nBinsX = static_cast<int>(ws_sptr->getXDimension()->getNBins());