How to region face count remove and reordering Like this in programmatically?

[JihoKang24]

I would like the behavior to change from what is shown in photo 1 to that in photo 2.
Could you please advise on how to reduce the number of faces within the selected area and re-arrange them accordingly?

Previously, I tried to achieve this by selecting the region and applying Decimate,
but this approach didn’t produce the result I was hoping for.

Thank you in advance.

[Grantim]

Hello!

As I can see on screenshots - it is MeshInspector/Brush/Patch tool. It has following code:

MeshLib/source/MRViewer/MRSurfaceManipulationWidget.cpp

Lines 373 to 447 in 8261ac6

	if ( settings_.workMode == WorkMode::Patch )
	{
	{
	// clear UV
	visualizationRegion_ |= generalEditingRegion_;
	expand( oldMesh.topology, visualizationRegion_, 2 );
	updateUVmap_( false );
	}
	const auto delFaces = getIncidentFaces( oldMesh.topology, generalEditingRegion_ );
	if ( delFaces.any() )
	{
	SCOPED_HISTORY( "Brush: Patch" );
	ownMeshChangedSignal_ = true;
	std::shared_ptr<Mesh> newMesh = std::make_shared<Mesh>( oldMesh );
	FaceBitSet newFaceSelection = obj_->getSelectedFaces() - delFaces;
	UndirectedEdgeBitSet newEdgeSelection = obj_->getSelectedEdges() - getInnerEdges( oldMesh.topology, delFaces ); // must be done before actual deletion
	auto bds = delRegionKeepBd( *newMesh, delFaces );
	const FaceBitSet oldFaces = newMesh->topology.getValidFaces();
	for ( const auto & bd : bds )
	{
	if ( bd.empty() )
	continue;
	// assert( isHoleBd( mesh.topology, bd ) ) can probably fail due to different construction of loops,
	// so we check every edge of every loop below
	const auto len = calcPathLength( bd, *newMesh );
	const auto avgLen = len / bd.size();
	FillHoleNicelySettings settings
	{
	.triangulateParams =
	{
	.metric = getUniversalMetric( *newMesh ),
	.multipleEdgesResolveMode = FillHoleParams::MultipleEdgesResolveMode::Strong
	},
	.maxEdgeLen = 2 * (float)avgLen,
	.edgeWeights = settings_.edgeWeights
	};
	settings.onEdgeSplit = [&] ( EdgeId e1, EdgeId e )
	{
	if ( newFaceSelection.test( newMesh->topology.left( e ) ) )
	newFaceSelection.autoResizeSet( newMesh->topology.left( e1 ) );
	if ( newFaceSelection.test( newMesh->topology.right( e ) ) )
	newFaceSelection.autoResizeSet( newMesh->topology.right( e1 ) );
	// if we split an edge with both unchangeable end vertices, then mark new vertex as unchangeable as well
	if ( unchangeableVerts_.test( newMesh->topology.org( e1 ) ) &&
	unchangeableVerts_.test( newMesh->topology.dest( e ) ) )
	unchangeableVerts_.autoResizeSet( newMesh->topology.org( e ) );
	};
	for ( auto e : bd )
	if ( !newMesh->topology.left( e ) )
	fillHoleNicely( *newMesh, e, settings );
	}
	if ( newFaceSelection != obj_->getSelectedFaces() )
	AppendHistory<ChangeMeshFaceSelectionAction>( "Change Face Selection", obj_, std::move( newFaceSelection ) );
	if ( newEdgeSelection != obj_->getSelectedEdges() )
	AppendHistory<ChangeMeshEdgeSelectionAction>( "Change Edge Selection", obj_, std::move( newEdgeSelection ) );
	// newFaces include both faces inside the patch and subdivided faces around
	const FaceBitSet newFaces = newMesh->topology.getValidFaces() - oldFaces;
	auto meshAttribs = projectMeshAttributes( *obj_, MeshPart( *newMesh, &newFaces ) );
	appendMeshChangeHistory_( std::move( newMesh ), newFaces );
	if ( meshAttribs )
	emplaceMeshAttributes( obj_, std::move( *meshAttribs ) );
	reallocData_( obj_->mesh()->topology.lastValidVert() + 1 );
	sameValidVerticesAsInOriginMesh_ = originalMesh_->topology.getValidVerts() == obj_->mesh()->topology.getValidVerts();
	setDeviationCalculationMethod( deviationCalculationMethod_ );
	obj_->setDirtyFlags( DIRTY_ALL );
	// otherwise whole surface becomes red after patch and before mouse move
	updateRegion_( mousePos_ );
	}
	}

Main idea is to delete selected faces and fill holes:

            auto bds = delRegionKeepBd( *newMesh, delFaces );
            for ( const auto & bd : bds )
            {
                if ( bd.empty() )
                    continue;
                // assert( isHoleBd( mesh.topology, bd ) ) can probably fail due to different construction of loops,
                // so we check every edge of every loop below
                const auto len = calcPathLength( bd, *newMesh );
                const auto avgLen = len / bd.size();
                FillHoleNicelySettings settings
                {
                    .triangulateParams =
                    {
                        .metric = getUniversalMetric( *newMesh ),
                        .multipleEdgesResolveMode = FillHoleParams::MultipleEdgesResolveMode::Strong
                    },
                    .maxEdgeLen = 2 * (float)avgLen,
                    .edgeWeights = settings_.edgeWeights
                };
                for ( auto e : bd )
                    if ( !newMesh->topology.left( e ) )
                        fillHoleNicely( *newMesh, e, settings );
            }

(other lines are needed for correct mesh attributes handling)

[Grantim]

"Previously, I tried to achieve this by selecting the region and applying Decimate"

It should work fine but you probably wanted to use "Remesh" instead of "Decimate"

[JihoKang24]

hello grantim

In our case, we need to protect the border region of the mesh during remeshing.
To do that, I tried identifying the boundary faces and excluding them from the remeshing region by marking them as false in the region mask.

However, the result doesn't work as I expected – the boundary region still gets modified.

// below code to save, border region,
    Mesh mesh = makeCube();
    VxConvertVxToMRMesh(pCMeshIn0, mesh);

    RemeshSettings settings;
    settings.targetEdgeLen = (float)dEdgeLength;
    settings.packMesh = false;
    FaceBitSet fsRegionPart(mesh.topology.faceSize(), true);

    for (auto f : mesh.topology.findBoundaryFaces())
    {
        EdgeId eTri[3];
        mesh.topology.getTriEdges(f, eTri);
        for (auto e : eTri)
        {
            for (auto eRing: orgRing(mesh.topology, e))
            {
                auto f = mesh.topology.left(eRing);
                if (fsRegionPart.test(f) == false)
                    continue;

                fsRegionPart.set(mesh.topology.left(eRing), false);
            }
        }
    }
    
    settings.region = &fsRegionPart;
    MR::remesh(mesh, settings);

My question:
Is this the correct approach to protect border faces during remeshing?

If not, what would be the recommended way to ensure the boundary region is preserved during remeshing?

Thank you very much for your help!

[Grantim]

Hello!

This code is a bit overcomplicated but the idea is correct:

    // below code to save, border region,
    Mesh mesh = makeCube();
    VxConvertVxToMRMesh(pCMeshIn0, mesh);

    RemeshSettings settings;
    settings.targetEdgeLen = (float)dEdgeLength;
    settings.packMesh = false;
    FaceBitSet fsRegionPart = mesh.topology.getValidFaces() - mesh.topology.findBoundaryFaces();
    settings.region = &fsRegionPart;
    MR::remesh(mesh, settings);

This way boundary will be saved, but in general it is not recommended. Could you please give a bit more context, why do you need to preserve boundary?