GeometryBuildFromSTL.cpp

Go to the documentation of this file.

// ==============================================================================================
// Microflow 3D, http://www.microflow.pwr.edu.pl/
// Created by Roman Szafran on 01.05.19.
// Copyright (c) 2019 Wroclaw University of Science and Technology.
// Distributed under the Apache License, Version 2.0. You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0 or see accompanying file license.txt.
// Redistributions of source code must retain the above copyright and license notice.
// ==============================================================================================

#include "GeometryBuildFromSTL.h"

void MF::GB::GeometryBuildFromSTL::SubtractsSTLGridsFromGeometryGrid(const bool verbose) {

    float voxelSize = m_ConfigData_Ptr->getCaseFloatParam("GeometryParams.VoxelSize");
    unsigned int nr = 1;
    std::string GridFileNameWithoutExtension = m_ConfigData_Ptr->GeometryFile.substr(0, m_ConfigData_Ptr->GeometryFile.length() - 4);
    std::string NewGridFileName = (GridFileNameWithoutExtension + std::to_string(nr) + ".stl");
    std::ifstream isFile(NewGridFileName);
    while (isFile.good()) {
        auto NewSTLMesher_Ptr = MF::GB::StlMesher::New(NewGridFileName, voxelSize, verbose);
        if (m_ConfigData_Ptr->getCaseFloatParam ("GeometryParams.AddInnerWall") != 0)
            MF::GB::GeometryBuildFromSTL::AddInnerWallToGrid(NewSTLMesher_Ptr->getVDBGrid_Ptr(),
                                                             m_ConfigData_Ptr->getCaseFloatParam(
                                                                     "GeometryParams.AddInnerWall"));
        MF::GB::differenceOfTwoGrids(m_STLGeometryGrid_Ptr, NewSTLMesher_Ptr->getVDBGrid_Ptr());
        std::cout << "Grid " << NewGridFileName << " has been subtracted from the geometry grid " << std::endl;
        NewSTLMesher_Ptr.reset();
        isFile.close();
        nr++;
        NewGridFileName = (GridFileNameWithoutExtension + std::to_string(nr) + ".stl");
        isFile.open(NewGridFileName);
    }
}

void MF::GB::GeometryBuildFromSTL::AutomaticBoundaryFind() {
    m_AutoSettingNode_Ptr = MF::GB::AutoSettingNode::New(m_ConfigData_Ptr, m_VDBInt64GeometryGrid_Ptr, m_LatticeParameters_Ptr, m_VDBPropagationGrid_Ptr);
    m_AutoSettingNode_Ptr->BoundaryFind();
}

void MF::GB::GeometryBuildFromSTL::AddInnerWallToGrid(const openvdb::FloatGrid::Ptr & VDBGrid_Ptr, const double ThinWallValue) {
    for (openvdb::FloatGrid::ValueOnIter iter = VDBGrid_Ptr->beginValueOn(); iter.test(); ++iter) {
        if ((iter.getValue() < ThinWallValue) and (iter.getValue() > -ThinWallValue))
            iter.setValue(1.0);
    }
}

void MF::GB::GeometryBuildFromSTL::BoundaryAddFromThreadFile() {
    MF::GB::BoundaryFromThread::VDBBoundaryAdd(m_VDBInt64GeometryGrid_Ptr, m_ConfigData_Ptr);
    m_AutoSettingNode_Ptr->DefaultTypeSet();
    m_AutoSettingNode_Ptr->NodeTypeClass();
}

void MF::GB::GeometryBuildFromSTL::FluidAddFromThreadFile() {
    MF::GB::FluidFromThread::VDBFluidAdd(m_VDBInt64GeometryGrid_Ptr, m_ConfigData_Ptr);
    m_AutoSettingNode_Ptr->BoundaryFind();
}

void MF::GB::GeometryBuildFromSTL::SolidAddFromThreadFile() {
    MF::GB::SolidFromThread::VDBSolidAdd(m_VDBInt64GeometryGrid_Ptr, m_ConfigData_Ptr);
    MF::GB::GeometryBuildFromSTL::NewPropagationTest();
    m_AutoSettingNode_Ptr->BoundaryFind();
}

void MF::GB::GeometryBuildFromSTL::WriteGeometryGridToVtiFile() {
    std::string GridFileName = (m_ConfigData_Ptr->GeometryFile.substr(0, m_ConfigData_Ptr->GeometryFile.length() - 4));
    double PhysVoxelSize = m_ConfigData_Ptr->getCaseFloatParam("GeometryParams.PhysicalVoxelSize");
    m_MFGrid_GeometryGrid_Ptr->saveToVTIFile<vtkIntArray>(GridFileName, "Node type", 1, PhysVoxelSize);
}

void MF::GB::GeometryBuildFromSTL::WriteGeometryGridToVDBFile() {
    std::string GridFileName = (m_ConfigData_Ptr->GeometryFile.substr(0, m_ConfigData_Ptr->GeometryFile.length() - 4));
    std::string GeometryName = m_ConfigData_Ptr->getCaseStringParam("GeometryParams.GeometryName");
    m_MFGrid_GeometryGrid_Ptr->setGridName(GeometryName);
    double PhysVoxelSize = m_ConfigData_Ptr->getCaseFloatParam("GeometryParams.PhysicalVoxelSize");
    m_MFGrid_GeometryGrid_Ptr->insertMetaDataFloat("Physical size of voxel", PhysVoxelSize);
    m_MFGrid_GeometryGrid_Ptr->saveToVDBFile(GridFileName);
}

void MF::GB::GeometryBuildFromSTL::Clean() {
    m_PropagationTest_Ptr.reset();
    m_PropagationGrid_Ptr.reset();
    m_VDBPropagationGrid_Ptr = nullptr;
    m_STLMesher_Ptr.reset();
    m_STLGeometryGrid_Ptr = nullptr;
    m_AutoSettingNode_Ptr.reset();
}

void MF::GB::GeometryBuildFromSTL::GeometryBuildFromSTL::ReadGrid(const bool verbose) {
    // Geometry reading and voxelization. Creation of float type of VDB levelSet grid
    m_STLMesher_Ptr = MF::GB::StlMesher::New(m_ConfigData_Ptr->GeometryFile, m_voxelSize, verbose);
    m_STLGeometryGrid_Ptr = m_STLMesher_Ptr->getVDBGrid_Ptr();

    // Here, one can add some operations on geometry grids (levelSet type) e.g. union etc.
    //-------------------------------------------------------------------------------------------------------------------------------------------------
    // Geometries with consecutive numbers 1,2,3... e.g geometry1.stl, geometry 2.stl are automatically substracted from the main grid (by default geometry.stl)
    MF::GB::GeometryBuildFromSTL::SubtractsSTLGridsFromGeometryGrid(verbose);
    //-------------------------------------------------------------------------------------------------------------------------------------------------

    // Change the VDB tree type to FogVolume from default LevelSet type.
    MF::GB::setGridToFogVolume<openvdb::FloatGrid::Ptr>(m_STLGeometryGrid_Ptr, true); // voxelize all Active Tiles true/false ---> (default = true). If true all acive tiles will be voxelized and the tree will increase in size

    // Set grid all active points to values 1.
    for (openvdb::FloatGrid::ValueOnIter iter = m_STLGeometryGrid_Ptr->beginValueOn(); iter.test(); ++iter)
        iter.setValue(1.0);

    // Create a propagation grid that nodes contain bitmaps of active propagation directions for all active nodes.
    m_PropagationGrid_Ptr = MF::Database::GridVDB<openvdb::Int32Grid>::New();
    m_VDBPropagationGrid_Ptr = m_PropagationGrid_Ptr->getVDBGridPtr();
    auto accessor = m_VDBPropagationGrid_Ptr->getAccessor();
    for (openvdb::FloatGrid::ValueOnIter iter = m_STLGeometryGrid_Ptr->beginValueOn(); iter.test(); ++iter)
        accessor.setValue(iter.getCoord(),1);     // Fill all active voxels of propagation grid (int32 type) with 1.
    m_PropagationTest_Ptr = MF::GU::PropagationD3Q19::New(m_VDBPropagationGrid_Ptr, m_LatticeParameters_Ptr);
    m_PropagationTest_Ptr->PropagationTest();

    // Change STLGeometryGrid to Int64 type
    m_MFGrid_GeometryGrid_Ptr = MF::Database::GridVDB<openvdb::Int64Grid>::New();
    m_VDBInt64GeometryGrid_Ptr = m_MFGrid_GeometryGrid_Ptr->getVDBGridPtr();
    auto accessor2 = m_VDBInt64GeometryGrid_Ptr->getAccessor();
    for (openvdb::FloatGrid::ValueOnIter iter = m_STLGeometryGrid_Ptr->beginValueOn(); iter.test(); ++iter)
        accessor2.setValue(iter.getCoord(),1);     // Fill all active voxels of geometry grid (int64 type) with 1.
}

void MF::GB::GeometryBuildFromSTL::NewPropagationTest() {
    auto accessor = m_VDBPropagationGrid_Ptr->getAccessor();
    for (openvdb::Int64Grid::ValueOnIter iter = m_VDBInt64GeometryGrid_Ptr->beginValueOn(); iter.test(); ++iter) {
        MF::GB::NodeID nodeTMP;
        nodeTMP.node_id.NodeID = iter.getValue();
        if (nodeTMP.node_id.Node.nodeType == 0) {
            accessor.setValueOff(iter.getCoord(), 0);     // Fill solid nodes with 0 value and set it off
        }
    }
    m_PropagationTest_Ptr->PropagationTest();
}