Addition of VTK import class

Modules/LemmaCore/CMakeLists.txt

@@ -46,7 +46,7 @@ if (LEMMA_ENABLE_TESTING)
 endif()
 
 # Install
-install (  TARGETS lemmacore DESTINATION ${CMAKE_INSTALL_PREFIX}/lib )
+install ( TARGETS lemmacore        DESTINATION ${CMAKE_INSTALL_PREFIX}/lib )
 install ( FILES include/LemmaCore  DESTINATION ${CMAKE_INSTALL_PREFIX}/include/Lemma ) 
 install ( DIRECTORY include/       DESTINATION ${CMAKE_INSTALL_PREFIX}/include/Lemma  FILES_MATCHING PATTERN "*.h" )
 

Modules/LemmaCore/include/LemmaCore

@@ -31,6 +31,7 @@
 #include "RectilinearGrid.h"
 #include "RectilinearGridReader.h"
 #include "RectilinearGridVTKExporter.h"
+#include "RectilinearGridVTKImporter.h"
 #include "WindowFilter.h"
 // helpers and utilities
 #include "banner.h"

Modules/LemmaCore/include/RectilinearGridVTKExporter.h

@@ -12,9 +12,9 @@
  * @date      09/25/2013 08:20:01 AM
  * @version   $Id$
  * @author    Trevor Irons (ti)
- * @email     Trevor.Irons@xri-geo.com
+ * @email     Trevor.Irons@LemmaSoftware.org
  * @copyright Copyright (c) 2013, XRI Geophysics, LLC
- * @copyright Copyright (c) 2013, Trevor Irons
+ * @copyright Copyright (c) 2013,2017,2018 Trevor Irons
  */
 
 

Modules/LemmaCore/include/RectilinearGridVTKImporter.h

@@ -0,0 +1,161 @@
+/* This file is part of Lemma, a geophysical modelling and inversion API.
+ * More information is available at http://lemmasoftware.org
+ */
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+/**
+ * @file
+ * @date      07/28/18 18:04:54
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@LemmaSoftware.org
+ * @copyright Copyright (c) 2018, University of Utah
+ * @copyright Copyright (c) 2018, Lemma Software, LLC
+ */
+
+#pragma once
+
+#ifndef  RECTILINEARGRIDVTKIMPORTER_INC
+#define  RECTILINEARGRIDVTKIMPORTER_INC
+
+#ifdef  LEMMAUSEVTK
+
+#pragma once
+#include "LemmaObject.h"
+#include "RectilinearGrid.h"
+
+#include "vtkSmartPointer.h"
+#include "vtkRectilinearGrid.h"
+#include "vtkDataArray.h"
+
+namespace Lemma {
+
+    /**
+     * \ingroup LemmaCore
+     * \brief
+     * \details
+     */
+    class RectilinearGridVTKImporter : public LemmaObject {
+
+        friend std::ostream &operator<<(std::ostream &stream, const RectilinearGridVTKImporter &ob);
+
+        protected:
+        /*
+         *  This key is used to lock the constructor. It is protected so that inhereted
+         *  classes also have the key to contruct their base class.
+         */
+        struct ctor_key {};
+
+        public:
+
+        // ====================  LIFECYCLE     =======================
+
+        /**
+         * Default constructor.
+         * @note This method is locked, and cannot be called directly.
+         *       The reason that the method is public is to enable the use
+         *       of make_shared whilst enforcing the use of shared_ptr,
+         *       in c++-17, this curiosity may be resolved.
+         * @see RectilinearGridVTKImporter::NewSP
+         */
+        explicit RectilinearGridVTKImporter ( const ctor_key& );
+
+        /**
+         * DeSerializing constructor.
+         * @note This method is locked, and cannot be called directly.
+         *       The reason that the method is public is to enable the use
+         *       of make_shared whilst enforcing the use of shared_ptr,
+         *       in c++-17, this curiosity may be resolved.
+         * @see RectilinearGridVTKImporter::DeSerialize
+         */
+        RectilinearGridVTKImporter ( const YAML::Node& node, const ctor_key& );
+
+        /**
+         * Default destructor.
+         * @note This method should never be called due to the mandated
+         *       use of smart pointers. It is necessary to keep the method
+         *       public in order to allow for the use of the more efficient
+         *       make_shared constructor.
+         */
+        virtual ~RectilinearGridVTKImporter ();
+
+        /**
+         *  Uses YAML to serialize this object.
+         *  @return a YAML::Node
+         *  @see RectilinearGridVTKImporter::DeSerialize
+         */
+        virtual YAML::Node Serialize() const;
+
+        /*
+         *  Factory method for generating concrete class.
+         *  @return a std::shared_ptr of type RectilinearGridVTKImporter
+         */
+        static std::shared_ptr< RectilinearGridVTKImporter > NewSP();
+
+        /**
+         *   Constructs an RectilinearGridVTKImporter object from a YAML::Node.
+         *   @see RectilinearGridVTKImporter::Serialize
+         */
+        static std::shared_ptr<RectilinearGridVTKImporter> DeSerialize(const YAML::Node& node);
+
+        // ====================  OPERATORS     =======================
+
+        // ====================  OPERATIONS    =======================
+
+        // ====================  ACCESS        =======================
+
+        /**
+         *  Sets the name of the VTK file to convert
+         */
+        void SetVTKInput( vtkSmartPointer<vtkRectilinearGrid> vgrid );
+
+        /**
+         *  Performs the actual grid conversion
+         */
+        void ConvertGrid( );
+
+
+        // ====================  INQUIRY       =======================
+        /**
+         *  Returns the name of the underlying class, similiar to Python's type
+         *  @return string of class name
+         */
+        virtual inline std::string GetName() const {
+            return CName;
+        }
+
+        protected:
+
+        // ====================  LIFECYCLE     =======================
+
+        /** Copy is disabled */
+        RectilinearGridVTKImporter( const RectilinearGridVTKImporter& ) = delete;
+
+        // ====================  DATA MEMBERS  =========================
+
+        private:
+
+        /** ASCII string representation of the class name */
+        static constexpr auto CName = "RectilinearGridVTKImporter";
+
+        /** VTK file to import */
+        vtkSmartPointer<vtkRectilinearGrid> vtkGrid;
+
+        std::shared_ptr<RectilinearGrid>  rGrid;
+
+    }; // -----  end of class  RectilinearGridVTKImporter  -----
+
+}  // -----  end of namespace Lemma ----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+
+
+#endif      // -----  LEMMAUSEVTK  -----
+
+#endif   // ----- #ifndef RECTILINEARGRIDVTKIMPORTER_INC  -----
+

Modules/LemmaCore/src/CMakeLists.txt

@@ -2,14 +2,15 @@ set (SOURCE
 	${SOURCE}
 	${CMAKE_CURRENT_SOURCE_DIR}/helper.cpp
 	${CMAKE_CURRENT_SOURCE_DIR}/LemmaObject.cpp
-	${CMAKE_CURRENT_SOURCE_DIR}/ASCIIParser.cpp                # fixed, key 
-	${CMAKE_CURRENT_SOURCE_DIR}/CubicSplineInterpolator.cpp    # fixed, key 
+	${CMAKE_CURRENT_SOURCE_DIR}/ASCIIParser.cpp                # key 
+	${CMAKE_CURRENT_SOURCE_DIR}/CubicSplineInterpolator.cpp    # key 
 	${CMAKE_CURRENT_SOURCE_DIR}/Grid.cpp                       # ABC, no key 
-	${CMAKE_CURRENT_SOURCE_DIR}/RectilinearGrid.cpp            # fixed, key
-	${CMAKE_CURRENT_SOURCE_DIR}/RectilinearGridReader.cpp      # fixed, key
-	${CMAKE_CURRENT_SOURCE_DIR}/RectilinearGridVTKExporter.cpp # fixed, key
+	${CMAKE_CURRENT_SOURCE_DIR}/RectilinearGrid.cpp            # key
+	${CMAKE_CURRENT_SOURCE_DIR}/RectilinearGridReader.cpp      # key
+	${CMAKE_CURRENT_SOURCE_DIR}/RectilinearGridVTKExporter.cpp # key
+	${CMAKE_CURRENT_SOURCE_DIR}/RectilinearGridVTKImporter.cpp # key
 	${CMAKE_CURRENT_SOURCE_DIR}/Filter.cpp                     # ABC, no key
-	${CMAKE_CURRENT_SOURCE_DIR}/WindowFilter.cpp			   # fixed, key
+	${CMAKE_CURRENT_SOURCE_DIR}/WindowFilter.cpp			   # key
 	${CMAKE_CURRENT_SOURCE_DIR}/EarthModel.cpp                 # ABC, no key
 	${CMAKE_CURRENT_SOURCE_DIR}/LayeredEarth.cpp			   # ABC, no key
 	${CMAKE_CURRENT_SOURCE_DIR}/Data.cpp                       # ABC, no key

Modules/LemmaCore/src/RectilinearGrid.cpp

@@ -16,7 +16,7 @@
 namespace Lemma {
 
     std::ostream &operator << (std::ostream &stream, const RectilinearGrid &ob) {
-        stream << ob.Serialize()  << "\n"; 
+        stream << ob.Serialize()  << "\n";
         return stream;
     }
 

Modules/LemmaCore/src/RectilinearGridVTKImporter.cpp

@@ -0,0 +1,142 @@
+/* This file is part of Lemma, a geophysical modelling and inversion API.
+ * More information is available at http://lemmasoftware.org
+ */
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+/**
+ * @file
+ * @date      07/28/18 18:05:24
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     Trevor.Irons@utah.edu
+ * @copyright Copyright (c) 2018, University of Utah
+ * @copyright Copyright (c) 2018, Lemma Software, LLC
+ */
+
+#include "RectilinearGridVTKImporter.h"
+
+namespace Lemma {
+
+    // ====================  FRIEND METHODS  =====================
+
+    std::ostream &operator << (std::ostream &stream, const RectilinearGridVTKImporter &ob) {
+        stream << ob.Serialize()  << "\n";
+        return stream;
+    }
+
+    // ====================  LIFECYCLE     =======================
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  RectilinearGridVTKImporter
+    //      Method:  RectilinearGridVTKImporter
+    // Description:  constructor (locked)
+    //--------------------------------------------------------------------------------------
+    RectilinearGridVTKImporter::RectilinearGridVTKImporter (const ctor_key&) : LemmaObject( LemmaObject::ctor_key()  ) {
+
+    }  // -----  end of method RectilinearGridVTKImporter::RectilinearGridVTKImporter  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  RectilinearGridVTKImporter
+    //      Method:  RectilinearGridVTKImporter
+    // Description:  DeSerializing constructor (locked)
+    //--------------------------------------------------------------------------------------
+    RectilinearGridVTKImporter::RectilinearGridVTKImporter (const YAML::Node& node, const ctor_key&) : LemmaObject(node, LemmaObject::ctor_key()) {
+
+    }  // -----  end of method RectilinearGridVTKImporter::RectilinearGridVTKImporter  (constructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  RectilinearGridVTKImporter
+    //      Method:  NewSP()
+    // Description:  public constructor returing a shared_ptr
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr< RectilinearGridVTKImporter >  RectilinearGridVTKImporter::NewSP() {
+        return std::make_shared< RectilinearGridVTKImporter >( ctor_key() );
+    }
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  RectilinearGridVTKImporter
+    //      Method:  ~RectilinearGridVTKImporter
+    // Description:  destructor (protected)
+    //--------------------------------------------------------------------------------------
+    RectilinearGridVTKImporter::~RectilinearGridVTKImporter () {
+
+    }  // -----  end of method RectilinearGridVTKImporter::~RectilinearGridVTKImporter  (destructor)  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  RectilinearGridVTKImporter
+    //      Method:  Serialize
+    //--------------------------------------------------------------------------------------
+    YAML::Node  RectilinearGridVTKImporter::Serialize (  ) const {
+        YAML::Node node = LemmaObject::Serialize();
+        node.SetTag( GetName() );
+        // FILL IN CLASS SPECIFICS HERE
+        return node;
+    }		// -----  end of method RectilinearGridVTKImporter::Serialize  -----
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  RectilinearGridVTKImporter
+    //      Method:  DeSerialize
+    //--------------------------------------------------------------------------------------
+    std::shared_ptr<RectilinearGridVTKImporter> RectilinearGridVTKImporter::DeSerialize ( const YAML::Node& node  ) {
+        if (node.Tag() !=  "RectilinearGridVTKImporter" ) {
+            throw  DeSerializeTypeMismatch( "RectilinearGridVTKImporter", node.Tag());
+        }
+        return std::make_shared< RectilinearGridVTKImporter > ( node, ctor_key() );
+    }		// -----  end of method RectilinearGridVTKImporter::DeSerialize  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  RectilinearGridVTKImporter
+    //      Method:  set_SetVTKInput
+    //--------------------------------------------------------------------------------------
+    void RectilinearGridVTKImporter::SetVTKInput ( vtkSmartPointer<vtkRectilinearGrid> vgrid  ) {
+        vtkGrid	= vgrid;
+
+        return ;
+    }		// -----  end of method RectilinearGridVTKImporter::set_SetVTKInput  -----
+
+
+    //--------------------------------------------------------------------------------------
+    //       Class:  RectilinearGridVTKImporter
+    //      Method:  ConvertGrid
+    //--------------------------------------------------------------------------------------
+    void RectilinearGridVTKImporter::ConvertGrid (  ) {
+        rGrid = RectilinearGrid::NewSP();
+
+        int dims[3];
+        vtkGrid->GetDimensions( dims );
+        auto xcoords = vtkGrid->GetXCoordinates(  );
+        auto ycoords = vtkGrid->GetYCoordinates(  );
+        auto zcoords = vtkGrid->GetZCoordinates(  );
+
+        VectorXr dx = VectorXr(dims[0]-1);
+        VectorXr dy = VectorXr(dims[1]-1);
+        VectorXr dz = VectorXr(dims[2]-1);
+
+        for (int ix=1; ix<dims[0]; ++ix) {
+            dx(ix-1) = xcoords->GetTuple1(ix) - xcoords->GetTuple1(ix-1);
+        }
+        for (int iy=1; iy<dims[1]; ++iy) {
+            dy(iy-1) = ycoords->GetTuple1(iy) - ycoords->GetTuple1(iy-1);
+        }
+        for (int iz=1; iz<dims[2]; ++iz) {
+            dz(iz-1) = zcoords->GetTuple1(iz) - zcoords->GetTuple1(iz-1);
+        }
+
+        rGrid->SetDimensions( dims[0], dims[1], dims[2] );
+        rGrid->SetOffset( xcoords->GetTuple1(0), ycoords->GetTuple1(0), zcoords->GetTuple1(0) );
+        rGrid->SetSpacing( dx, dy, dz  );
+
+        return ;
+    }		// -----  end of method RectilinearGridVTKImporter::ConvertGrid  -----
+
+
+} // ----  end of namespace Lemma  ----
+
+/* vim: set tabstop=4 expandtab: */
+/* vim: set filetype=cpp: */
+