foamVtkToolsI.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | www.openfoam.com
     \\/     M anipulation  |
-------------------------------------------------------------------------------
    Copyright (C) 2017-2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.

    OpenFOAM is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
    for more details.

    You should have received a copy of the GNU General Public License
    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.

\*---------------------------------------------------------------------------*/

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

inline Foam::UList<uint8_t> Foam::vtk::Tools::asUList
(
    vtkUnsignedCharArray* array,
    const label size
)
{
    array->SetNumberOfComponents(1);
    array->SetNumberOfTuples(size);

    return UList<uint8_t>(array->WritePointer(0, size), size);
}


inline Foam::UList<vtkIdType> Foam::vtk::Tools::asUList
(
    vtkIdTypeArray* array,
    const label size
)
{
    array->SetNumberOfComponents(1);
    array->SetNumberOfTuples(size);

    return UList<vtkIdType>(array->WritePointer(0, size), size);
}


inline vtkSmartPointer<vtkPoints>
Foam::vtk::Tools::Points(const UList<point>& pts)
{
    auto vtkpoints = vtkSmartPointer<vtkPoints>::New();

    vtkpoints->SetNumberOfPoints(pts.size());

    vtkIdType pointId = 0;
    for (const point& pt : pts)
    {
        vtkpoints->SetPoint(pointId++, pt.v_);
    }

    return vtkpoints;
}


inline vtkSmartPointer<vtkPoints>
Foam::vtk::Tools::Points(const UList<point>& pts, const labelUList& addr)
{
    auto vtkpoints = vtkSmartPointer<vtkPoints>::New();

    vtkpoints->SetNumberOfPoints(addr.size());

    vtkIdType pointId = 0;
    for (const label pointi : addr)
    {
        vtkpoints->SetPoint(pointId++, pts[pointi].v_);
    }

    return vtkpoints;
}


inline vtkSmartPointer<vtkPolyData>
Foam::vtk::Tools::Vertices(const UList<point>& pts)
{
    auto vtkmesh = vtkSmartPointer<vtkPolyData>::New();

    vtkmesh->SetPoints(Tools::Points(pts));
    vtkmesh->SetVerts(Tools::identityVertices(pts.size()));

    return vtkmesh;
}


inline vtkSmartPointer<vtkPolyData>
Foam::vtk::Tools::Vertices(const UList<point>& pts, const labelUList& addr)
{
    auto vtkmesh = vtkSmartPointer<vtkPolyData>::New();

    vtkmesh->SetPoints(Tools::Points(pts, addr));
    vtkmesh->SetVerts(Tools::identityVertices(addr.size()));

    return vtkmesh;
}


inline Foam::scalarMinMax Foam::vtk::Tools::rangeOf(vtkDataArray* data)
{
    double range[2]{GREAT, -GREAT};

    if (data)
    {
        if (data->GetNumberOfComponents() == 1)
        {
            data->GetRange(range);
        }
        else
        {
            // Mag
            data->GetRange(range, -1);
        }
    }

    return scalarMinMax(range[0], range[1]);
}


inline vtkSmartPointer<vtkCellArray> Foam::vtk::Tools::identityVertices
(
    const label size
)
{
    auto cells = vtkSmartPointer<vtkCellArray>::New();

    #ifdef VTK_CELL_ARRAY_V2

    // Offsets
    // [0, n1, n1+n2, n1+n2+n3... ]

    auto offsets = vtkSmartPointer<vtkIdTypeArray>::New();

    {
        const vtkIdType nOffsets(size+1);

        offsets->SetNumberOfTuples(nOffsets);

        vtkIdType* iter = offsets->WritePointer(0, nOffsets);

        std::iota(iter, (iter + nOffsets), vtkIdType(0));
    }


    auto connect = vtkSmartPointer<vtkIdTypeArray>::New();

    // Connectivity
    {
        const vtkIdType nConnect(size);

        connect->SetNumberOfTuples(nConnect);

        vtkIdType* iter = connect->WritePointer(0, nConnect);

        std::iota(iter, (iter + nConnect), vtkIdType(0));
    }

    // Move into a vtkCellArray

    cells->SetData(offsets, connect);

    #else

    // In VTK-8.2.0 and older,
    // sizes are interwoven (prefixed) in the connectivity

    // Connectivity size, with prefixed size information

    // Cell connectivity for vertex
    // [size, ids.., size, ids...]  -> therefore  [1, id, 1, id, ...]

    const vtkIdType nElem(size);
    const vtkIdType nConnect(2*size);

    {
        cells->GetData()->SetNumberOfTuples(nConnect);

        vtkIdType* iter = cells->WritePointer(nElem, nConnect);

        // Fill in the connectivity array, with prefixed size information

        for (vtkIdType id = 0; id < nElem; ++id)
        {
            *(iter++) = 1;
            *(iter++) = id;
        }
    }

    #endif

    return cells;
};


template<class Type>
inline void Foam::vtk::Tools::foamToVtkTuple
(
    float output[],
    const Type& val
)
{
    for (direction cmpt=0; cmpt < pTraits<Type>::nComponents; ++cmpt)
    {
        output[cmpt] = component(val, cmpt);
    }
    remapTuple<Type>(output);
}


template<class Type>
inline void Foam::vtk::Tools::foamToVtkTuple
(
    double output[],
    const Type& val
)
{
    for (direction cmpt=0; cmpt < pTraits<Type>::nComponents; ++cmpt)
    {
        output[cmpt] = component(val, cmpt);
    }
    remapTuple<Type>(output);
}


// ************************************************************************* //