surfaceHookUp.C

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     | Website:  https://openfoam.org
    \\  /    A nd           | Copyright (C) 2014-2026 OpenFOAM Foundation
     \\/     M anipulation  |
-------------------------------------------------------------------------------
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/>.
 
Application
    surfaceHookUp
 
Description
    Find close open edges and stitches the surface along them
 
Usage
    - surfaceHookUp \‍( surface1.stl surface2.stl \‍) hookDistance
 
\*---------------------------------------------------------------------------*/
 
#include "argList.H"
#include "triSurface.H"
#include "indexedOctree.H"
#include "treeDataEdge.H"
#include "PackedBoolList.H"
 
using namespace Foam;
 
// Split facei along edgeI at position newPointi
void greenRefine
(
    const triSurface& surf,
    const label facei,
    const label edgeI,
    const label newPointi,
    DynamicList<labelledTri>& newFaces
)
{
    const labelledTri& f = surf.localFaces()[facei];
    const edge& e = surf.edges()[edgeI];
 
    // Find index of edge in face.
 
    label fp0 = findIndex(f, e[0]);
    label fp1 = f.fcIndex(fp0);
    label fp2 = f.fcIndex(fp1);
 
    if (f[fp1] == e[1])
    {
        // Edge oriented like face
        newFaces.append
        (
            labelledTri
            (
                f[fp0],
                newPointi,
                f[fp2],
                f.region()
            )
        );
        newFaces.append
        (
            labelledTri
            (
                newPointi,
                f[fp1],
                f[fp2],
                f.region()
            )
        );
    }
    else
    {
        newFaces.append
        (
            labelledTri
            (
                f[fp2],
                newPointi,
                f[fp1],
                f.region()
            )
        );
        newFaces.append
        (
            labelledTri
            (
                newPointi,
                f[fp0],
                f[fp1],
                f.region()
            )
        );
    }
}
 
 
void createBoundaryEdgeTrees
(
    const PtrList<triSurface>& surfs,
    PtrList<indexedOctree<treeDataEdge>>& bEdgeTrees,
    labelListList& treeBoundaryEdges
)
{
    forAll(surfs, surfI)
    {
        const triSurface& surf = surfs[surfI];
 
        // Boundary edges
        treeBoundaryEdges[surfI] =
            labelList
            (
                identityMap
                (
                    surf.nInternalEdges(),
                    surf.nEdges() - surf.nInternalEdges()
                )
            );
 
        randomGenerator rndGen(17301893);
 
        // Slightly extended bb. Slightly off-centred just so on symmetric
        // geometry there are less face/edge aligned items.
        treeBoundBox bb
        (
            treeBoundBox(UList<point>(surf.localPoints())).extend(1e-4)
        );
 
        bEdgeTrees.set
        (
            surfI,
            new indexedOctree<treeDataEdge>
            (
                treeDataEdge
                (
                    false,                      // cachebb
                    surf.edges(),               // edges
                    surf.localPoints(),         // points
                    treeBoundaryEdges[surfI]    // selected edges
                ),
                bb,     // bb
                8,      // maxLevel
                10,     // leafsize
                3.0     // duplicity
            )
       );
    }
}
 
 
class findNearestOpSubset
{
    const indexedOctree<treeDataEdge>& tree_;
 
    DynamicList<label>& shapeMask_;
 
public:
 
    findNearestOpSubset
    (
        const indexedOctree<treeDataEdge>& tree,
        DynamicList<label>& shapeMask
    )
    :
        tree_(tree),
        shapeMask_(shapeMask)
    {}
 
    void operator()
    (
        const labelUList& indices,
        const point& sample,
 
        scalar& nearestDistSqr,
        label& minIndex,
        point& nearestPoint
    ) const
    {
        const treeDataEdge& shape = tree_.shapes();
 
        forAll(indices, i)
        {
            const label index = indices[i];
            const label edgeIndex = shape.edgeLabels()[index];
 
            if
            (
                !shapeMask_.empty()
             && findIndex(shapeMask_, edgeIndex) != -1
            )
            {
                continue;
            }
 
            const edge& e = shape.edges()[edgeIndex];
 
            pointHit nearHit = e.line(shape.points()).nearestDist(sample);
 
            // Only register hit if closest point is not an edge point
            if (nearHit.hit())
            {
                scalar distSqr = sqr(nearHit.distance());
 
                if (distSqr < nearestDistSqr)
                {
                    nearestDistSqr = distSqr;
                    minIndex = index;
                    nearestPoint = nearHit.rawPoint();
                }
            }
        }
    }
};
 
 
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
int main(int argc, char *argv[])
{
    argList::addNote
    (
        "Hook surfaces to other surfaces by moving and re-triangulating \n"
        "their boundary edges to match other surface boundary edges"
    );
 
    #include "removeCaseOptions.H"
 
    argList::noParallel();
    argList::validArgs.append("surface files");
    argList::validArgs.append("hook distance");
    argList args(argc, argv);
 
    const fileNameList surfFileNames(args.argRead<fileNameList>(1));
 
    Info<< endl;
    PtrList<triSurface> surfs(surfFileNames.size());
    forAll(surfs, surfi)
    {
        surfs.set(surfi, new triSurface(surfFileNames[surfi]));
 
        Info<< "Reading "
            << surfFileNames[surfi].c_str() << ':' << endl;
 
        Info<< incrIndent << indent << "Regions = (";
        forAll(surfs[surfi].patches(), surfPatchi)
        {
            if (surfPatchi) Info << ' ';
            Info<< surfs[surfi].patches()[surfPatchi].name();
        }
        Info << ')' << decrIndent << nl << endl;
    }
 
    const scalar dist(args.argRead<scalar>(2));
    const scalar matchTolerance(max(1e-6*dist, small));
    Info<< "Hooking distance = " << dist << endl;
 
    const label maxIters = 100;
 
    PtrList<indexedOctree<treeDataEdge>> bEdgeTrees(surfs.size());
    labelListList treeBoundaryEdges(surfs.size());
 
    List<DynamicList<labelledTri>> newFaces(surfs.size());
    List<DynamicList<point>> newPoints(surfs.size());
    List<PackedBoolList> visitedFace(surfs.size());
 
    PtrList<triSurface> newSurfs(surfs.size());
    forAll(surfs, surfi)
    {
        newSurfs.set(surfi, new triSurface(surfs[surfi]));
    }
 
    label nChanged = 0;
    label nIters = 1;
 
    do
    {
        Info<< nl << "Iteration = " << nIters++ << endl;
        nChanged = 0;
 
        createBoundaryEdgeTrees(newSurfs, bEdgeTrees, treeBoundaryEdges);
 
        forAll(newSurfs, surfI)
        {
            const triSurface& newSurf = newSurfs[surfI];
 
            newFaces[surfI] = newSurf.localFaces();
            newPoints[surfI] = newSurf.localPoints();
            visitedFace[surfI] = PackedBoolList(newSurf.size(), false);
        }
 
        forAll(newSurfs, surfI)
        {
            const triSurface& surf = newSurfs[surfI];
 
            List<pointIndexHit> bPointsTobEdges(surf.boundaryPoints().size());
            labelList bPointsHitTree(surf.boundaryPoints().size(), -1);
 
            const labelListList& pointEdges = surf.pointEdges();
 
            forAll(bPointsTobEdges, bPointi)
            {
                pointIndexHit& nearestHit = bPointsTobEdges[bPointi];
 
                const label pointi = surf.boundaryPoints()[bPointi];
                const point& samplePt = surf.localPoints()[pointi];
 
                const labelList& pEdges = pointEdges[pointi];
 
                // Add edges connected to the edge to the shapeMask
                DynamicList<label> shapeMask;
                shapeMask.append(pEdges);
 
                forAll(bEdgeTrees, treeI)
                {
                    const indexedOctree<treeDataEdge>& bEdgeTree =
                        bEdgeTrees[treeI];
 
                    pointIndexHit currentHit =
                        bEdgeTree.findNearest
                        (
                            samplePt,
                            sqr(dist),
                            findNearestOpSubset
                            (
                                bEdgeTree,
                                shapeMask
                            )
                        );
 
                    if
                    (
                        currentHit.hit()
                     &&
                        (
                            !nearestHit.hit()
                         ||
                            (
                                magSqr(currentHit.hitPoint() - samplePt)
                              < magSqr(nearestHit.hitPoint() - samplePt)
                            )
                        )
                    )
                    {
                        nearestHit = currentHit;
                        bPointsHitTree[bPointi] = treeI;
                    }
                }
 
                scalar dist2 = magSqr(nearestHit.rawPoint() - samplePt);
 
                if (nearestHit.hit())
                {
                    if (dist2 > Foam::sqr(dist))
                    {
                        nearestHit.setMiss();
                    }
                }
            }
 
            forAll(bPointsTobEdges, bPointi)
            {
                const pointIndexHit& eHit = bPointsTobEdges[bPointi];
 
                if (eHit.hit())
                {
                    const label hitSurfI = bPointsHitTree[bPointi];
                    const triSurface& hitSurf = newSurfs[hitSurfI];
 
                    const label eIndex =
                        treeBoundaryEdges[hitSurfI][eHit.index()];
                    const edge& e = hitSurf.edges()[eIndex];
 
                    const label pointi = surf.boundaryPoints()[bPointi];
 
                    const labelList& eFaces = hitSurf.edgeFaces()[eIndex];
 
                    if (eFaces.size() != 1)
                    {
                        WarningInFunction
                            << "Edge is attached to " << eFaces.size()
                            << " faces." << endl;
 
                        continue;
                    }
 
                    const label facei = eFaces[0];
 
                    if (visitedFace[hitSurfI][facei])
                    {
                        continue;
                    }
 
                    DynamicList<labelledTri> newFacesFromSplit(2);
 
                    const point& pt = surf.localPoints()[pointi];
 
                    if
                    (
                        (
                            magSqr(pt - hitSurf.localPoints()[e.start()])
                          < matchTolerance
                        )
                     || (
                            magSqr(pt - hitSurf.localPoints()[e.end()])
                          < matchTolerance
                        )
                    )
                    {
                        continue;
                    }
 
                    nChanged++;
 
                    label newPointi = -1;
 
                    // Keep the points in the same place and move the edge
                    if (hitSurfI == surfI)
                    {
                        newPointi = pointi;
                    }
                    else
                    {
                        newPoints[hitSurfI].append(newPoints[surfI][pointi]);
                        newPointi = newPoints[hitSurfI].size() - 1;
                    }
 
                    // Split the other face.
                    greenRefine
                    (
                        hitSurf,
                        facei,
                        eIndex,
                        newPointi,
                        newFacesFromSplit
                    );
 
                    visitedFace[hitSurfI][facei] = true;
 
                    forAll(newFacesFromSplit, newFacei)
                    {
                        const labelledTri& fN = newFacesFromSplit[newFacei];
 
                        if (newFacei == 0)
                        {
                            newFaces[hitSurfI][facei] = fN;
                        }
                        else
                        {
                            newFaces[hitSurfI].append(fN);
                        }
                    }
                }
            }
        }
 
        Info<< "    Number of edges split = " << nChanged << endl;
 
        forAll(newSurfs, surfi)
        {
            newSurfs.set
            (
                surfi,
                new triSurface
                (
                    newFaces[surfi],
                    newSurfs[surfi].patches(),
                    pointField(newPoints[surfi])
                )
            );
        }
 
    } while (nChanged > 0 && nIters <= maxIters);
 
    Info<< endl;
 
    forAll(newSurfs, surfi)
    {
        const fileName newSurfFileName =
            surfFileNames[surfi].lessExt()
          + "_hooked."
          + surfFileNames[surfi].ext();
 
        Info<< "Writing hooked surface " << newSurfFileName << endl;
 
        newSurfs[surfi].write(newSurfFileName);
    }
 
    Info<< "\nEnd\n" << endl;
 
    return 0;
}
 
 
// ************************************************************************* //