gsWriteParaview.h

Go to the documentation of this file.

#include <gsCore/gsForwardDeclarations.h>
#include <gsCore/gsExport.h>

#include <sstream>
#include <fstream>

#pragma once

#define NS 1000


namespace gismo {


template<class T>
void gsWriteParaview(const gsGeometry<T> & Geo, std::string const & fn, 
                     unsigned npts=NS, bool mesh = false, bool ctrlNet = false);

template<class T>
void gsWriteParaview(gsMappedSpline<2,T> const& mspline,
                     std::string const & fn,unsigned npts = NS);




template<class T>
void gsWriteParaview(gsMultiPatch<T> const& mp, gsMultiBasis<T> const& mb,
                     std::string const & fn, unsigned npts = NS);

template<class T>
void gsWriteParaview(gsFunctionSet<T> const& geom,
                     gsMappedBasis<2,T>  const& mbasis,
                     std::string const & fn,unsigned npts = NS, 
                     const bool fullsupport = false,
                     const std::vector<index_t> indices = std::vector<index_t>());

//template <class T>
//void gsWriteParaview(gsMesh<T> const& sl, std::string const & fn, bool pvd = true);

template <class T>
void gsWriteParaview(gsMesh<T> const& sl, std::string const & fn, const gsMatrix<T>& params);

GISMO_EXPORT void gsWriteParaview(const gsSurfMesh & sm,
                                  std::string const & fn,
                                  std::initializer_list<std::string> props = {});
    
template <typename T>
void gsWriteParaview(const std::vector<gsMesh<T> >& meshes, std::string const& fn);


template<class T>
void gsWriteParaview(const gsField<T> & field, std::string const & fn, 
                     unsigned npts=NS, bool mesh = false, const std::string pDelim = "");

template<class T>
void gsWriteParaview(gsFunctionSet<T> const& geo, gsFunctionSet<T> const& func,
                     std::string const & fn, unsigned npts = NS, const std::string pDelim = "");

template<class T>
void gsWriteParaview(const gsMultiPatch<T> & Geo, std::string const & fn, 
                     unsigned npts=NS, bool mesh = false, bool ctrlNet = false, const std::string pDelim = "_")
{
    gsWriteParaview( Geo.patches(), fn, npts, mesh, ctrlNet, pDelim);
}

template<class T>
void gsWriteParaview( std::vector<gsGeometry<T> *> const & Geo, 
                      std::string const & fn, unsigned npts=NS,
                      bool mesh = false, bool ctrlNet = false, const std::string pDelim = "_");

template<class T>
void gsWriteParaview(const gsMultiBasis<T> & mb, const gsMultiPatch<T> & domain,
                     std::string const & fn, unsigned npts);

template<class T>
void gsWriteParaview_basisFnct(int i, gsBasis<T> const& basis, 
                               std::string const & fn, unsigned npts =NS);


template<class T>
void gsWriteParaview(const gsGeometrySlice<T> & Geo,
                     std::string const & fn, unsigned npts =NS);

template<class T>
void gsWriteParaview(gsFunctionSet<T> const& func,
                     std::string const & fn,
                     unsigned npts =NS);

template<class T>
void gsWriteParaview(gsFunction<T> const& func, 
                     gsMatrix<T> const& supp, 
                     std::string const & fn, 
                     unsigned npts =NS,
                     bool graph = true);

template<class T>
void gsWriteParaview(gsBasis<T> const& basis, std::string const & fn, 
                     unsigned npts =NS, bool mesh = false);

template<class T>
void gsWriteParaview(gsHBox<2,T> & box, std::string const & fn);

template<class T>
void gsWriteParaview(gsHBoxContainer<2,T> & box, std::string const & fn);


template<class T>
void gsWriteParaviewPoints(gsMatrix<T> const& X, 
                           gsMatrix<T> const& Y, 
                           std::string const & fn);

template<class T>
void gsWriteParaviewPoints(gsMatrix<T> const& X,
                           gsMatrix<T> const& Y,
                           gsMatrix<T> const& Z,
                           std::string const & fn);

template<class T>
void gsWriteParaviewPoints(gsMatrix<T> const& points, std::string const & fn);

//template<class T>
//void gsWriteParaviewTPgrid(gsMatrix<T> const& points,
//                          gsMatrix<T> const& data,
//                           const gsVector<index_t> & np,
//                           std::string const & fn);

template <class T>
void gsWriteParaview(gsSolid<T> const& sl, std::string const & fn, 
                     unsigned numPoints_for_eachCurve=50, int vol_Num=0,
                     T edgeThick=0.01, gsVector3d<T> const & translate=gsVector3d<T>(0,0,0), 
                     int color_convex=0, int color_nonconvex=20, int color_eloop=10,
                     std::vector<unsigned> const & eloop=std::vector<unsigned>());

template <class T>
void gsWriteParaviewSolid(gsSolid<T> const& sl, 
                          std::string const & fn, 
                          unsigned numSamples = NS);

template<class T>
void gsWriteParaview(gsCurveLoop<T> const & cloop, std::string const & fn, unsigned npts)
{
    std::vector<gsGeometry<T> *> all_curves;
    for(index_t j =0; j< cloop.numCurves() ; j++)
        all_curves.push_back( const_cast<gsCurve<T> *>(cloop.curve(j)) );

    gsWriteParaview( all_curves, fn, npts);       
}

template<class T>
void gsWriteParaview(gsPlanarDomain<T> const & pdomain, 
                     std::string const & fn, unsigned npts=NS);

template<class T>
void gsWriteParaview(const gsTrimSurface<T> & ts, std::string const & fn, 
                     unsigned npts=NS, bool trimCurves = false);

template<typename T>
void gsWriteParaview(const gsVolumeBlock<T>& volBlock,
                     std::string const & fn,
                     unsigned npts = NS);

template<class T>
void gsWriteParaviewBdr(gsMultiPatch<T> const & patches,
                     std::string const & fn,
                     unsigned npts, bool ctrlNet);

template<class T>
void gsWriteParaviewIfc(gsMultiPatch<T> const & patches,
                     std::string const & fn,
                     unsigned npts, bool ctrlNet);                            
                                 
template<class T>
void gsWriteParaview(gsMultiPatch<T> const & patches,
                     typename gsBoundaryConditions<T>::bcContainer const & bcs,
                     std::string const & fn, unsigned npts=NS, bool ctrlNet=false);

template<typename T>
void gsWriteParaviewTrimmedCurve(const gsTrimSurface<T>& surf,
                                 const unsigned idLoop,
                                 const unsigned idCurve,
                                 const std::string fn,
                                 unsigned npts = NS);

// function to plot a field on a single patch
template<class T>
void writeSinglePatchField(const gsFunction<T> & geometry,
                           const gsFunction<T> & parField,
                           const bool isParam,
                           std::string const & fn, unsigned npts);

template<class T>
void writeSingleCompMesh(const gsBasis<T> & basis, const gsGeometry<T> & Geo,
                         std::string const & fn, unsigned resolution = 8);

template<class T>
void writeSingleHBox(gsHBox<2,T> & box, std::string const & fn);

template<class T>
void writeSingleControlNet(const gsGeometry<T> & Geo,
                           std::string const & fn);

// Please document
template <class T>
void plot_errors(const gsMatrix<T> & orig, 
                 const gsMatrix<T> & comp,
                 std::vector<T> const & errors,
                 std::string const & fn);


#ifdef GISMO_WITH_PYBIND11

  void pybind11_init_gsWriteParaview(pybind11::module &m);

#endif // GISMO_WITH_PYBIND11


} // namespace gismo



#undef NS


#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsWriteParaview.hpp)
#endif