commands/face_manipulate.cpp - initial - spivag/command_occ

commands/face_manipulate.cpp
456 строк14 KB
Степанов Никита
Запрос на слияние 'topology_iterators' (#3) из topology_iterators в initial
27 апр 2026, 21:55
27 апр 2026, 21:55c047a95
//
//  face_manipulate.c
//  test
//
//  Created by Alexander Spivakov on 10.04.2025.
//

#include "face_manipulate.h"

#include <shape_iterator.h>
#include <builder.h>

#include <algorithm>
#include <vector>
#include <numeric>


TransFaceGeometry::Chamfer::Chamfer( double distance )
  : m_offset( distance )
{
}

bool TransFaceGeometry::Chamfer::AreParametersValid() const
{
  return m_offset > 0.;
}

TransFaceGeometry::Distance::Distance( double distance )
  : m_distance{ distance } {};

TransFaceGeometry::Angle::Angle( double angle )
  : m_angle( angle )
{
}

TransFaceGeometry::Radius::Radius( double radius )
  : m_radius{ radius }
{
}

TransFaceGeometry::Chord::Chord( double chord )
  : m_chord{ chord }
{
}

EdgeView::EdgesList::EdgesList( std::vector< std::shared_ptr< IBrepEdgeHandle > > const& edges )
  : m_edges{ edges }
{
}

EdgeView::FaceFace::FaceFace( std::shared_ptr< IBrepFaceHandle > const& baseFace,
                              std::shared_ptr< IBrepFaceHandle > coFace )

  : m_BaseFace{ baseFace }
  , m_CoFace{ coFace } {};

EdgeView::FaceEdge::FaceEdge( std::shared_ptr< IBrepFaceHandle > const& baseFace,
                              std::shared_ptr< IBrepEdgeHandle > edgeOnFace )

  : m_BaseFace{ baseFace }
  , m_EdgeOnFace{ edgeOnFace }
{
}

TransFaceGeometry::Fillet::Fillet( TransFaceGeometry::Radius const& radius, std::optional< double > const& shapeFactor )
  : m_geometry{ radius }
  , m_shapeFactor{ shapeFactor }
{
}

// TransFaceGeometry::Fillet::Fillet( TransFaceGeometry::Chord const& chord, std::optional< double > const& shapeFactor
// )
//   : m_geometry{ chord }
//   , m_shapeFactor{ shapeFactor }
//{
// }

bool TransFaceGeometry::Fillet::AreParametersValid() const
{
  if ( std::holds_alternative< TransFaceGeometry::Radius >( m_geometry ) )
  {
    return std::get< TransFaceGeometry::Radius >( m_geometry ).m_radius >= 0.;
  }
  else if ( std::holds_alternative< TransFaceGeometry::Chord >( m_geometry ) )
  {
    return std::get< TransFaceGeometry::Chord >( m_geometry ).m_chord > 0.;
  }
  else
  {
    throw BadCommand{ "Unhandled fillet geometry" };
  }
}

// Конструктор
BuildWallViaFaceRemove::BuildWallViaFaceRemove( std::shared_ptr< IShapeBuilder > const& originalBrep,
                                                std::shared_ptr< IBrepFaceHandle > const& faceToRemove,
                                                double thicknessOuter,
                                                double thicknessInner )
  : m_baseBrep{ originalBrep }
  , m_faceToRemove{ 1, faceToRemove }
  , m_thickknessToOuter{ thicknessOuter }
  , m_thickknessToInner{ thicknessInner }
{
}

// Конструктор
BuildWallViaFaceRemove::BuildWallViaFaceRemove( std::shared_ptr< IShapeBuilder > const& originalBrep,
                                                std::vector<std::shared_ptr< IBrepFaceHandle >> const& facesToRemove,
                                                double thicknessOuter,
                                                double thicknessInner )
  : m_baseBrep{ originalBrep }
  , m_faceToRemove{ facesToRemove }
  , m_thickknessToOuter{ thicknessOuter }
  , m_thickknessToInner{ thicknessInner }
{
}

// Конструктор
BuildWallViaFaceRemove::BuildWallViaFaceRemove( std::shared_ptr< IFaceBrepIterator > const& facesToRemoveIterator,
                                                double thicknessOuter,
                                                double thicknessInner )
  : m_baseBrep{ facesToRemoveIterator != nullptr ? facesToRemoveIterator->Shape().lock() : nullptr }
  , m_faceToRemove{}
  , m_thickknessToOuter{ thicknessOuter }
  , m_thickknessToInner{ thicknessInner }
{
  if ( m_baseBrep != nullptr )
  {
    auto nextHandle{ facesToRemoveIterator->Next() };
    while ( nextHandle != nullptr )
    {
      auto faceHandle{ facesToRemoveIterator->FaceHandle() };
      if ( faceHandle != nullptr )
      {
        m_faceToRemove.push_back( faceHandle );
      }
      nextHandle = facesToRemoveIterator->Next();
    }
  }
}

void BuildWallViaFaceRemove::Accept( ShapeVisitor& visitor ) const
{
  visitor.Visit( *this );
}

BuildWallViaFaceRemove::ValidateResult BuildWallViaFaceRemove::Validate() const
{
  ValidateResult result{
      m_baseBrep != nullptr,
      ( m_faceToRemove.size() > 0 )
          && ( std::all_of(
              cbegin( m_faceToRemove ), cend( m_faceToRemove ), []( const auto& fi ) { return fi != nullptr; } ) ),
      ( m_thickknessToOuter >= 0.0 ) && ( m_thickknessToInner >= 0.0 ),
      false };
  result.overallValidate = result.validateOriginal && result.validateFace && result.validateThickness;
  return result;
}

// конструктор
BuildOffsetFaces::BuildOffsetFaces( std::shared_ptr< IShapeBuilder > const& originalBrep,
                                    std::shared_ptr< IBrepFaceHandle > const& faceToOffset,
                                    double offsetDistance )
  : m_baseBrep{ originalBrep }
  , m_facesToOffset{ faceToOffset }
  , m_offsetDistance( offsetDistance )
{
}

void BuildOffsetFaces::Accept( ShapeVisitor& visitor ) const
{
  visitor.Visit( *this );
}

BuildChamfer::Symmetric::Symmetric( EdgeView::EdgesList const& edges, TransFaceGeometry::Distance const& distance )
  : m_internalLocation{ edges }
  , m_geometry{ distance }
{
}

// BuildChamfer::Symmetric::Symmetric( FacesMeet::EdgesList const & edges, TransFaceGeometry::Chord const & chord )
//: m_internalLocation{edges}
//, m_geometry{chord}
//{
//}

BuildChamfer::Symmetric::Symmetric( EdgeView::FaceFace const& faces, TransFaceGeometry::Distance const& distance )
  : m_internalLocation{ faces }
  , m_geometry{ distance }
{
}

// BuildChamfer::Symmetric::Symmetric( FacesMeet::FaceFace const & faces, TransFaceGeometry::Chord const & chord )
//: m_internalLocation{faces}
//, m_geometry{chord}
//{
//}

BuildChamfer::NonSymmetric::NonSymmetric( EdgeView::FaceFace const& faces,
                                          TransFaceGeometry::Distance const& distanceOnFirstFace,
                                          TransFaceGeometry::Distance const& distanceOnSecondFace )
  : m_internalLocation{ faces }
  , m_distanceBaseFace{ distanceOnFirstFace }
  , m_geometryOtherFace{ distanceOnSecondFace }
{
}

BuildChamfer::NonSymmetric::NonSymmetric( EdgeView::FaceEdge const& faceEdge,
                                          TransFaceGeometry::Distance const& distanceOnFirstFace,
                                          TransFaceGeometry::Distance const& distanceOnSecondFace )
  : m_internalLocation{ faceEdge }
  , m_distanceBaseFace{ distanceOnFirstFace }
  , m_geometryOtherFace{ distanceOnSecondFace }
{
}

BuildChamfer::BuildChamfer( std::shared_ptr< IShapeBuilder > const& originalBrep,
                            BuildChamfer::Symmetric const& symmetricChamferParametes )
  : m_originalBrep{ originalBrep }
  , asSymmetricChamferOpt{ symmetricChamferParametes }
{
}

BuildChamfer::BuildChamfer( std::shared_ptr< IShapeBuilder > const& originalBrep,
                            BuildChamfer::NonSymmetric const& nonSymmetricChamferParametes )
  : m_originalBrep{ originalBrep }
  , asNonSymmetricChamferOpt{ nonSymmetricChamferParametes }
{
}

void BuildChamfer::Accept( ShapeVisitor& visitor ) const
{
  visitor.Visit( *this );
}

BuildFillet::Symmetric::Symmetric( EdgeView::EdgesList const& edges, TransFaceGeometry::Radius const& distance )
  : m_geometry{ distance }
  , m_internalLocation{ edges }
{
}

BuildFillet::Symmetric::Symmetric( EdgeView::FaceFace const& facesPair, TransFaceGeometry::Radius const& distance )
  : m_geometry{ distance }
  , m_internalLocation{ facesPair }
{
}

BuildFillet::Symmetric::Symmetric( EdgeView::EdgesList const& edges,
                                   TransFaceGeometry::Fillet const& variableShapeFillet )
  : m_geometry{ variableShapeFillet }
  , m_internalLocation{ edges }
{
}

BuildFillet::Symmetric::Symmetric( EdgeView::FaceFace const& facesPair,
                                   TransFaceGeometry::Fillet const& variableShapeFillet )
  : m_geometry{ variableShapeFillet }
  , m_internalLocation{ facesPair }
{
}

BuildFillet::NonSymmetric::NonSymmetric( EdgeView::FaceEdge const& faceEdge,
                                         TransFaceGeometry::Distance const& raiusBaseFace,
                                         TransFaceGeometry::Distance const& radiusOtherFace )
  : m_internalLocation{ faceEdge }
  , m_radiusBaseFace{ raiusBaseFace }
  , m_radiusOtherFace{ radiusOtherFace }
{
}

BuildFillet::NonSymmetric::NonSymmetric( EdgeView::FaceFace const& faceFace,
                                         TransFaceGeometry::Distance const& raiusBaseFace,
                                         TransFaceGeometry::Distance const& radiusOtherFace )
  : m_internalLocation{ faceFace }
  , m_radiusBaseFace{ raiusBaseFace }
  , m_radiusOtherFace{ radiusOtherFace }
{
}

BlendMate::BlendMate( EdgesSelect prolong, FilletsMeet smoothBetweenFillets, CornerBlend smoothInCorners )
  : m_prolongMode{ prolong }
  , m_filletSurfacesJoin{ smoothBetweenFillets }
  , m_cornerFillet{ smoothInCorners }
{
}

BuildFillet::BuildFillet( std::shared_ptr< IShapeBuilder > const& originalBrep,
                          BuildFillet::Symmetric const& symmetricFilletParametes,
                          std::optional< BlendMate > const& multipleEdgesFilletSettings )
  : m_originalBrep{ originalBrep }
  , m_buildParameters{ symmetricFilletParametes }
  , m_severalEdgesFillet{ multipleEdgesFilletSettings }
{
}

BuildFillet::BuildFillet( std::shared_ptr< IShapeBuilder > const& originalBrep,
                          NonSymmetric const& nonSymmetricFilletParametes,
                          std::optional< BlendMate > const& multipleEdgesFilletSettings )
  : m_originalBrep{ originalBrep }
  , m_buildParameters{ nonSymmetricFilletParametes }
  , m_severalEdgesFillet{ multipleEdgesFilletSettings }
{
}

void BuildFillet::Accept( ShapeVisitor& visitor ) const
{
  visitor.Visit( *this );
}

// Execute implementations

void BuildFillet::Execute()
{
  if ( m_shape != nullptr )
    return;

  if ( m_originalBrep == nullptr )
    return;
  auto baseShape = m_originalBrep->GetShape();
  if ( baseShape == nullptr )
    return;

  if ( !std::holds_alternative< Symmetric >( m_buildParameters ) )
  {
    m_executionMessage = "BuildFillet: NonSymmetric fillet is not implemented";
    return;
  }
  auto const& sym = std::get< Symmetric >( m_buildParameters );
  if ( !std::holds_alternative< EdgeView::EdgesList >( sym.m_internalLocation ) )
  {
    m_executionMessage = "BuildFillet: FaceFace location is not implemented";
    return;
  }
  auto const& edgesList = std::get< EdgeView::EdgesList >( sym.m_internalLocation );

  double radius = 0.;
  if ( std::holds_alternative< TransFaceGeometry::Radius >( sym.m_geometry ) )
    radius = std::get< TransFaceGeometry::Radius >( sym.m_geometry ).m_radius;
  else if ( std::holds_alternative< TransFaceGeometry::Fillet >( sym.m_geometry ) )
  {
    auto const& fillet = std::get< TransFaceGeometry::Fillet >( sym.m_geometry );
    if ( std::holds_alternative< TransFaceGeometry::Radius >( fillet.m_geometry ) )
      radius = std::get< TransFaceGeometry::Radius >( fillet.m_geometry ).m_radius;
    else
    {
      m_executionMessage = "BuildFillet: Chord-based fillet is not implemented";
      return;
    }
  }
  if ( radius <= 0. )
    return;

  auto filletBuilder = OCCBuilderFactory::CreateFilletBuilder();
  for ( auto const& edgeHandle : edgesList.m_edges )
  {
    if ( !edgeHandle )
      continue;
    auto occEdge = std::dynamic_pointer_cast< OCCEdge >( edgeHandle->GetEdge() );
    if ( occEdge )
      filletBuilder->AddEdge( occEdge, radius );
  }
  filletBuilder->Create( baseShape );
  if ( filletBuilder->IsDone() )
    m_shape = filletBuilder->GetShape();
}

std::string BuildFillet::ExecutionMessage()
{
  return m_executionMessage;
}

void BuildChamfer::Execute()
{
  if ( m_shape != nullptr )
    return;

  if ( m_originalBrep == nullptr )
    return;
  auto baseShape = m_originalBrep->GetShape();
  if ( baseShape == nullptr )
    return;

  if ( !asSymmetricChamferOpt.has_value() )
    return;
  auto const& sym = *asSymmetricChamferOpt;
  if ( !std::holds_alternative< EdgeView::EdgesList >( sym.m_internalLocation ) )
    return;
  auto const& edgesList = std::get< EdgeView::EdgesList >( sym.m_internalLocation );

  if ( !std::holds_alternative< TransFaceGeometry::Distance >( sym.m_geometry ) )
    return;
  double dist = std::get< TransFaceGeometry::Distance >( sym.m_geometry ).m_distance;
  if ( dist <= 0. )
    return;

  auto chamferBuilder = OCCBuilderFactory::CreateChamferBuilder();
  for ( auto const& edgeHandle : edgesList.m_edges )
  {
    if ( !edgeHandle )
      continue;
    auto faceItr = ::CreateFaceIterator( edgeHandle );
    if ( !faceItr || !faceItr->HasNext() )
      continue;
    faceItr->Next();
    auto faceHandle = faceItr->FaceHandle();
    if ( !faceHandle )
      continue;
    auto occEdge = std::dynamic_pointer_cast< OCCEdge >( edgeHandle->GetEdge() );
    auto occFace = std::dynamic_pointer_cast< OCCFace >( faceHandle->GetFace() );
    if ( occEdge && occFace )
      chamferBuilder->AddEdge( occEdge, occFace, dist );
  }
  chamferBuilder->Create( baseShape );
  if ( chamferBuilder->IsDone() )
    m_shape = chamferBuilder->GetShape();
}

std::string BuildChamfer::ExecutionMessage()
{
  return m_executionMessage;
}

// GetParameters implementations

BuildWallViaFaceRemove::Parameters BuildWallViaFaceRemove::GetParameters() const
{
  Parameters params;
  params.m_baseBrep = m_baseBrep;
  params.m_facesToRemove = m_faceToRemove;
  params.m_thicknessOuter = m_thickknessToOuter;
  params.m_thicknessInner = m_thickknessToInner;
  return params;
}

BuildOffsetFaces::Parameters BuildOffsetFaces::GetParameters() const
{
  Parameters params;
  params.m_baseBrep = m_baseBrep;
  params.m_facesToOffset = m_facesToOffset;
  params.m_offsetDistance = m_offsetDistance;
  return params;
}

BuildChamfer::Parameters BuildChamfer::GetParameters() const
{
  Parameters params;
  params.m_originalBrep = m_originalBrep;
  params.asSymmetric = asSymmetricChamferOpt;
  params.asNonSymmetric = asNonSymmetricChamferOpt;
  return params;
}

BuildFillet::Parameters BuildFillet::GetParameters() const
{
  return Parameters{ m_originalBrep, m_buildParameters, m_severalEdgesFillet };
}