mirror of
https://github.com/Open-Cascade-SAS/OCCT.git
synced 2026-05-11 01:58:22 +08:00
9df5967d6e
New class XSAlgo_ShapeProcessor is added. It reimplements functionality of XSAlgo_AlgoContainer and makes it more convenient to use. XSAlgo_AlgoContainer is now internally uses methods of XSAlgo_ShapeProcessor when possible. New overload of Perform() method is added to class ShapeProcess. It accepts a set of flags that defines required operations instead of string.
311 lines
9.9 KiB
C++
311 lines
9.9 KiB
C++
// Created on: 2000-08-21
|
|
// Created by: Andrey BETENEV
|
|
// Copyright (c) 2000-2014 OPEN CASCADE SAS
|
|
//
|
|
// This file is part of Open CASCADE Technology software library.
|
|
//
|
|
// This library is free software; you can redistribute it and/or modify it under
|
|
// the terms of the GNU Lesser General Public License version 2.1 as published
|
|
// by the Free Software Foundation, with special exception defined in the file
|
|
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
|
// distribution for complete text of the license and disclaimer of any warranty.
|
|
//
|
|
// Alternatively, this file may be used under the terms of Open CASCADE
|
|
// commercial license or contractual agreement.
|
|
|
|
#include <ShapeProcess.hxx>
|
|
|
|
#include <NCollection_DataMap.hxx>
|
|
#include <Message_Messenger.hxx>
|
|
#include <Message_Msg.hxx>
|
|
#include <Message_ProgressScope.hxx>
|
|
#include <ShapeProcess_Context.hxx>
|
|
#include <ShapeProcess_Operator.hxx>
|
|
#include <Standard_ErrorHandler.hxx>
|
|
#include <Standard_Failure.hxx>
|
|
#include <TColStd_SequenceOfAsciiString.hxx>
|
|
#include <TCollection_AsciiString.hxx>
|
|
|
|
static NCollection_DataMap<TCollection_AsciiString, Handle(ShapeProcess_Operator)> aMapOfOperators;
|
|
|
|
namespace
|
|
{
|
|
//! Simple RAII class to lock the scope of the current operation.
|
|
class ScopeLock
|
|
{
|
|
public:
|
|
//! Constructor.
|
|
//! Locks the scope of the current operation.
|
|
//! @param theContext the context to lock.
|
|
//! @param theScopeName the name of the scope to lock.
|
|
ScopeLock(ShapeProcess_Context& theContext, const char* theScopeName)
|
|
: myContext(theContext)
|
|
{
|
|
myContext.SetScope(theScopeName);
|
|
}
|
|
|
|
//! Destructor.
|
|
//! Unlocks the scope of the current operation.
|
|
~ScopeLock()
|
|
{
|
|
myContext.UnSetScope();
|
|
}
|
|
|
|
private:
|
|
ShapeProcess_Context& myContext; //!< The context to lock.
|
|
};
|
|
}
|
|
|
|
|
|
//=======================================================================
|
|
//function : RegisterOperator
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
Standard_Boolean ShapeProcess::RegisterOperator (const Standard_CString name,
|
|
const Handle(ShapeProcess_Operator)& op)
|
|
{
|
|
if (aMapOfOperators.IsBound(name)) {
|
|
#ifdef OCCT_DEBUG
|
|
std::cout << "Warning: operator with name " << name << " is already registered!" << std::endl;
|
|
#endif
|
|
return Standard_False;
|
|
}
|
|
aMapOfOperators.Bind( name, op );
|
|
return Standard_True;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : FindOperator
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
Standard_Boolean ShapeProcess::FindOperator (const Standard_CString name,
|
|
Handle(ShapeProcess_Operator)& op)
|
|
{
|
|
if (!aMapOfOperators.IsBound(name)) {
|
|
#ifdef OCCT_DEBUG
|
|
std::cout << "Error: no operator with name " << name << " registered!" << std::endl;
|
|
#endif
|
|
return Standard_False;
|
|
}
|
|
op = aMapOfOperators.ChangeFind(name);
|
|
return !op.IsNull();
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Perform
|
|
//purpose :
|
|
//=======================================================================
|
|
|
|
Standard_Boolean ShapeProcess::Perform (const Handle(ShapeProcess_Context)& context,
|
|
const Standard_CString seq,
|
|
const Message_ProgressRange& theProgress)
|
|
{
|
|
ScopeLock aSequenceScope(*context, seq);
|
|
|
|
// get description of the sequence
|
|
TCollection_AsciiString sequence;
|
|
if ( ! context->GetString ( "exec.op", sequence ) ) {
|
|
#ifdef OCCT_DEBUG
|
|
std::cout << "Error: ShapeProcess_Performer::Perform: sequence not defined for " << seq << std::endl;
|
|
#endif
|
|
if ( context->TraceLevel() >0 ) {
|
|
Message_Msg SMSG3 ("SP.Sequence.Warn.NoSeq"); // Sequence %s not found
|
|
context->Messenger()->Send (SMSG3 << seq, Message_Warning);
|
|
}
|
|
return Standard_False;
|
|
}
|
|
TColStd_SequenceOfAsciiString sequenceOfOperators;
|
|
TCollection_AsciiString oper;
|
|
Standard_Integer i;
|
|
for ( i=1; ; i++ ) {
|
|
oper = sequence.Token ( " \t,;", i );
|
|
if ( oper.Length() <=0 ) break;
|
|
sequenceOfOperators.Append(oper);
|
|
}
|
|
|
|
// put a message
|
|
if ( context->TraceLevel() >=2 ) {
|
|
Message_Msg SMSG0 ("SP.Sequence.Info.Seq"); //Sequence of operators: %s
|
|
TCollection_AsciiString Seq;
|
|
for ( Standard_Integer i1=1; i1 <= sequenceOfOperators.Length(); i1++ ) {
|
|
if (i1 > 1) Seq += ",";
|
|
Seq += sequenceOfOperators.Value(i1);
|
|
}
|
|
SMSG0.Arg (Seq.ToCString());
|
|
context->Messenger()->Send (SMSG0, Message_Info);
|
|
}
|
|
|
|
// iterate on operators in the sequence
|
|
Standard_Boolean isDone = Standard_False;
|
|
Message_ProgressScope aPS(theProgress, NULL, sequenceOfOperators.Length());
|
|
for (i = 1; i<=sequenceOfOperators.Length() && aPS.More(); i++)
|
|
{
|
|
oper = sequenceOfOperators.Value(i);
|
|
Message_ProgressRange aRange = aPS.Next();
|
|
|
|
if ( context->TraceLevel() >=2 ) {
|
|
Message_Msg SMSG5 ("SP.Sequence.Info.Operator"); //Operator %d/%d: %s
|
|
SMSG5 << i << sequenceOfOperators.Length() << oper.ToCString();
|
|
context->Messenger()->Send (SMSG5, Message_Alarm);
|
|
}
|
|
|
|
Handle(ShapeProcess_Operator) op;
|
|
if ( ! ShapeProcess::FindOperator ( oper.ToCString(), op ) ) {
|
|
if ( context->TraceLevel() >0 ) {
|
|
Message_Msg SMSG1 ("SP.Sequence.Error.NoOp"); //Operator %s not found
|
|
context->Messenger()->Send (SMSG1 << oper, Message_Alarm);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
ScopeLock anOperationScope(*context, oper.ToCString());
|
|
try {
|
|
OCC_CATCH_SIGNALS
|
|
if (op->Perform(context, aRange))
|
|
isDone = Standard_True;
|
|
}
|
|
catch (Standard_Failure const& anException) {
|
|
Message_Msg SMSG2 ("SP.Sequence.Error.Except"); //Operator %s failed with exception %s
|
|
SMSG2 << oper << anException.GetMessageString();
|
|
context->Messenger()->Send (SMSG2, Message_Alarm);
|
|
}
|
|
}
|
|
|
|
return isDone;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : Perform
|
|
//purpose :
|
|
//=======================================================================
|
|
Standard_Boolean ShapeProcess::Perform(const Handle(ShapeProcess_Context)& theContext,
|
|
const OperationsFlags& theOperations,
|
|
const Message_ProgressRange& theProgress)
|
|
{
|
|
if (!theContext)
|
|
{
|
|
return Standard_False;
|
|
}
|
|
|
|
std::vector<std::pair<const char*, Handle(ShapeProcess_Operator)>> anOperators = getOperators(theOperations);
|
|
if (anOperators.empty())
|
|
{
|
|
return Standard_False;
|
|
}
|
|
|
|
Standard_Boolean anIsAnySuccess = Standard_False;
|
|
Message_ProgressScope aProgressScope(theProgress, nullptr, static_cast<Standard_Real>(anOperators.size()));
|
|
for (const auto& anOperator : anOperators)
|
|
{
|
|
const char* anOperationName = anOperator.first;
|
|
const Handle(ShapeProcess_Operator)& anOperation = anOperator.second;
|
|
Message_ProgressRange aProgressRange = aProgressScope.Next();
|
|
ScopeLock anOperationScope(*theContext, anOperationName); // Set operation scope.
|
|
try
|
|
{
|
|
OCC_CATCH_SIGNALS;
|
|
anIsAnySuccess |= anOperation->Perform(theContext, aProgressRange);
|
|
}
|
|
catch (const Standard_Failure& anException)
|
|
{
|
|
Message_Msg aMessage("SP.Sequence.Error.Except"); //Operator %s failed with exception %s
|
|
aMessage << anOperationName << anException.GetMessageString();
|
|
theContext->Messenger()->Send(aMessage, Message_Alarm);
|
|
}
|
|
}
|
|
return anIsAnySuccess;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : getOperators
|
|
//purpose :
|
|
//=======================================================================
|
|
std::vector<std::pair<const char*, Handle(ShapeProcess_Operator)>> ShapeProcess::getOperators(const OperationsFlags& theFlags)
|
|
{
|
|
std::vector<std::pair<const char*, Handle(ShapeProcess_Operator)>> aResult;
|
|
for (std::underlying_type<Operation>::type anOperation = Operation::First; anOperation < Operation::Count; ++anOperation)
|
|
{
|
|
if (theFlags.test(anOperation))
|
|
{
|
|
const char* anOperationName = toOperationName(static_cast<Operation>(anOperation));
|
|
if (!anOperationName)
|
|
{
|
|
continue;
|
|
}
|
|
Handle(ShapeProcess_Operator) anOperator;
|
|
if (FindOperator(anOperationName, anOperator))
|
|
{
|
|
aResult.emplace_back(anOperationName, anOperator);
|
|
}
|
|
}
|
|
}
|
|
return aResult;
|
|
}
|
|
|
|
//=======================================================================
|
|
//function : toOperationName
|
|
//purpose :
|
|
//=======================================================================
|
|
const char* ShapeProcess::toOperationName(const Operation theOperation)
|
|
{
|
|
switch (theOperation)
|
|
{
|
|
case Operation::DirectFaces:
|
|
return "DirectFaces";
|
|
|
|
case Operation::SameParameter:
|
|
return "SameParameter";
|
|
|
|
case Operation::SetTolerance:
|
|
return "SetTolerance";
|
|
|
|
case Operation::SplitAngle:
|
|
return "SplitAngle";
|
|
|
|
case Operation::BSplineRestriction:
|
|
return "BSplineRestriction";
|
|
|
|
case Operation::ElementaryToRevolution:
|
|
return "ElementaryToRevolution";
|
|
|
|
case Operation::SweptToElementary:
|
|
return "SweptToElementary";
|
|
|
|
case Operation::SurfaceToBSpline:
|
|
return "SurfaceToBSpline";
|
|
|
|
case Operation::ToBezier:
|
|
return "ToBezier";
|
|
|
|
case Operation::SplitContinuity:
|
|
return "SplitContinuity";
|
|
|
|
case Operation::SplitClosedFaces:
|
|
return "SplitClosedFaces";
|
|
|
|
case Operation::FixWireGaps:
|
|
return "FixWireGaps";
|
|
|
|
case Operation::FixFaceSize:
|
|
return "FixFaceSize";
|
|
|
|
case Operation::DropSmallSolids:
|
|
return "DropSmallSolids";
|
|
|
|
case Operation::DropSmallEdges:
|
|
return "DropSmallEdges";
|
|
|
|
case Operation::FixShape:
|
|
return "FixShape";
|
|
|
|
case Operation::SplitClosedEdges:
|
|
return "SplitClosedEdges";
|
|
|
|
case Operation::SplitCommonVertex:
|
|
return "SplitCommonVertex";
|
|
}
|
|
return nullptr;
|
|
}
|