OCCT

// Created on: 1995-12-08
// Created by: Jacques GOUSSARD
// Copyright (c) 1995-1999 Matra Datavision
// Copyright (c) 1999-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 <BRepCheck_Analyzer.hxx>

#include <BRepCheck_Edge.hxx>
#include <BRepCheck_Face.hxx>
#include <BRepCheck_ListIteratorOfListOfStatus.hxx>
#include <BRepCheck_Result.hxx>
#include <BRepCheck_Shell.hxx>
#include <BRepCheck_Solid.hxx>
#include <BRepCheck_Vertex.hxx>
#include <BRepCheck_Wire.hxx>
#include <NCollection_Array1.hxx>
#include <NCollection_Shared.hxx>
#include <OSD_Parallel.hxx>
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>
#include <Standard_Mutex.hxx>
#include <Standard_NullObject.hxx>
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Shape.hxx>
#include <TopTools_MapOfShape.hxx>

//! Functor for multi-threaded execution.
class BRepCheck_ParallelAnalyzer
{
public:
  BRepCheck_ParallelAnalyzer(NCollection_Array1<NCollection_Array1<TopoDS_Shape>>& theArray,
                             const BRepCheck_IndexedDataMapOfShapeResult&          theMap)
      : myArray(theArray),
        myMap(theMap)
  {
    //
  }

  void operator()(const Standard_Integer theVectorIndex) const
  {
    TopExp_Explorer exp;
    for (Standard_Integer aShapeIter = myArray[theVectorIndex].Lower();
         aShapeIter <= myArray[theVectorIndex].Upper();
         ++aShapeIter)
    {
      const TopoDS_Shape&             aShape  = myArray[theVectorIndex][aShapeIter];
      const TopAbs_ShapeEnum          aType   = aShape.ShapeType();
      const Handle(BRepCheck_Result)& aResult = myMap.FindFromKey(aShape);
      switch (aType)
      {
        case TopAbs_VERTEX: {
          // modified by NIZHNY-MKK  Wed May 19 16:56:16 2004.BEGIN
          // There is no need to check anything.
          //       if (aShape.IsSame(S)) {
          //  myMap(S)->Blind();
          //       }
          // modified by NIZHNY-MKK  Wed May 19 16:56:23 2004.END
          break;
        }
        case TopAbs_EDGE: {
          try
          {
            Handle(BRepCheck_Edge) aResEdge = Handle(BRepCheck_Edge)::DownCast(aResult);
            const BRepCheck_Status ste =
              aResEdge->CheckPolygonOnTriangulation(TopoDS::Edge(aShape));
            if (ste != BRepCheck_NoError)
            {
              aResEdge->SetStatus(ste);
            }
          }
          catch (Standard_Failure const& anException)
          {
            (void)anException;
            if (!aResult.IsNull())
            {
              aResult->SetFailStatus(aShape);
            }
          }

          TopTools_MapOfShape MapS;
          for (exp.Init(aShape, TopAbs_VERTEX); exp.More(); exp.Next())
          {
            const TopoDS_Shape&      aVertex      = exp.Current();
            Handle(BRepCheck_Result) aResOfVertex = myMap.FindFromKey(aVertex);
            try
            {
              OCC_CATCH_SIGNALS
              if (MapS.Add(aVertex))
              {
                aResOfVertex->InContext(aShape);
              }
            }
            catch (Standard_Failure const& anException)
            {
              (void)anException;
              if (!aResult.IsNull())
              {
                aResult->SetFailStatus(aShape);
              }

              if (!aResOfVertex.IsNull())
              {
                aResOfVertex->SetFailStatus(aVertex);
                aResOfVertex->SetFailStatus(aShape);
              }
            }
          }
          break;
        }
        case TopAbs_WIRE: {
          break;
        }
        case TopAbs_FACE: {
          TopTools_MapOfShape MapS;
          for (exp.Init(aShape, TopAbs_VERTEX); exp.More(); exp.Next())
          {
            Handle(BRepCheck_Result) aFaceVertexRes = myMap.FindFromKey(exp.Current());
            try
            {
              OCC_CATCH_SIGNALS
              if (MapS.Add(exp.Current()))
              {
                aFaceVertexRes->InContext(aShape);
              }
            }
            catch (Standard_Failure const& anException)
            {
              (void)anException;
              if (!aResult.IsNull())
              {
                aResult->SetFailStatus(aShape);
              }
              if (!aFaceVertexRes.IsNull())
              {
                aFaceVertexRes->SetFailStatus(exp.Current());
                aFaceVertexRes->SetFailStatus(aShape);
              }
            }
          }

          Standard_Boolean performwire        = Standard_True;
          Standard_Boolean isInvalidTolerance = Standard_False;
          MapS.Clear();
          for (exp.Init(aShape, TopAbs_EDGE); exp.More(); exp.Next())
          {
            const Handle(BRepCheck_Result)& aFaceEdgeRes = myMap.FindFromKey(exp.Current());
            try
            {
              OCC_CATCH_SIGNALS
              if (MapS.Add(exp.Current()))
              {
                aFaceEdgeRes->InContext(aShape);

                if (performwire)
                {
                  Standard_Mutex::Sentry aLock(aFaceEdgeRes->GetMutex());
                  if (aFaceEdgeRes->IsStatusOnShape(aShape))
                  {
                    BRepCheck_ListIteratorOfListOfStatus itl(aFaceEdgeRes->StatusOnShape(aShape));
                    for (; itl.More(); itl.Next())
                    {
                      const BRepCheck_Status ste = itl.Value();
                      if (ste == BRepCheck_NoCurveOnSurface
                          || ste == BRepCheck_InvalidCurveOnSurface || ste == BRepCheck_InvalidRange
                          || ste == BRepCheck_InvalidCurveOnClosedSurface)
                      {
                        performwire = Standard_False;
                        break;
                      }
                    }
                  }
                }
              }
            }
            catch (Standard_Failure const& anException)
            {
              (void)anException;
              if (!aResult.IsNull())
              {
                aResult->SetFailStatus(aShape);
              }
              if (!aFaceEdgeRes.IsNull())
              {
                aFaceEdgeRes->SetFailStatus(exp.Current());
                aFaceEdgeRes->SetFailStatus(aShape);
              }
            }
          }

          Standard_Boolean orientofwires = performwire;
          for (exp.Init(aShape, TopAbs_WIRE); exp.More(); exp.Next())
          {
            const Handle(BRepCheck_Result)& aFaceWireRes = myMap.FindFromKey(exp.Current());
            try
            {
              OCC_CATCH_SIGNALS
              aFaceWireRes->InContext(aShape);

              if (orientofwires)
              {
                Standard_Mutex::Sentry aLock(aFaceWireRes->GetMutex());
                if (aFaceWireRes->IsStatusOnShape(aShape))
                {
                  const BRepCheck_ListOfStatus& aStatusList = aFaceWireRes->StatusOnShape(aShape);
                  BRepCheck_ListIteratorOfListOfStatus itl(aStatusList);
                  for (; itl.More(); itl.Next())
                  {
                    BRepCheck_Status ste = itl.Value();
                    if (ste != BRepCheck_NoError)
                    {
                      orientofwires = Standard_False;
                      break;
                    }
                  }
                }
              }
            }
            catch (Standard_Failure const& anException)
            {
              (void)anException;
              if (!aResult.IsNull())
              {
                aResult->SetFailStatus(aShape);
              }
              if (!aFaceWireRes.IsNull())
              {
                aFaceWireRes->SetFailStatus(exp.Current());
                aFaceWireRes->SetFailStatus(aShape);
              }
            }
          }

          try
          {
            OCC_CATCH_SIGNALS
            const Handle(BRepCheck_Face) aFaceRes = Handle(BRepCheck_Face)::DownCast(aResult);
            if (isInvalidTolerance)
            {
              aFaceRes->SetStatus(BRepCheck_InvalidToleranceValue);
            }
            else if (performwire)
            {
              if (orientofwires)
              {
                aFaceRes->OrientationOfWires(Standard_True); // on enregistre
              }
              else
              {
                aFaceRes->SetUnorientable();
              }
            }
            else
            {
              aFaceRes->SetUnorientable();
            }
          }
          catch (Standard_Failure const& anException)
          {
            (void)anException;
            if (!aResult.IsNull())
            {
              aResult->SetFailStatus(aShape);
            }

            for (exp.Init(aShape, TopAbs_WIRE); exp.More(); exp.Next())
            {
              Handle(BRepCheck_Result) aFaceCatchRes = myMap.FindFromKey(exp.Current());
              if (!aFaceCatchRes.IsNull())
              {
                aFaceCatchRes->SetFailStatus(exp.Current());
                aFaceCatchRes->SetFailStatus(aShape);
                aResult->SetFailStatus(exp.Current());
              }
            }
          }
          break;
        }
        case TopAbs_SHELL: {
          break;
        }
        case TopAbs_SOLID: {
          exp.Init(aShape, TopAbs_SHELL);
          for (; exp.More(); exp.Next())
          {
            const TopoDS_Shape&      aShell    = exp.Current();
            Handle(BRepCheck_Result) aSolidRes = myMap.FindFromKey(aShell);
            try
            {
              OCC_CATCH_SIGNALS
              aSolidRes->InContext(aShape);
            }
            catch (Standard_Failure const& anException)
            {
              (void)anException;
              if (!aResult.IsNull())
              {
                aResult->SetFailStatus(aShape);
              }
              if (!aSolidRes.IsNull())
              {
                aSolidRes->SetFailStatus(exp.Current());
                aSolidRes->SetFailStatus(aShape);
              }
            }
          }
          break;
        }
        default: {
          break;
        }
      }
    }
  }

private:
  BRepCheck_ParallelAnalyzer& operator=(const BRepCheck_ParallelAnalyzer&) Standard_DELETE;

private:
  NCollection_Array1<NCollection_Array1<TopoDS_Shape>>& myArray;
  const BRepCheck_IndexedDataMapOfShapeResult&          myMap;
};

//=================================================================================================

void BRepCheck_Analyzer::Init(const TopoDS_Shape& theShape, const Standard_Boolean B)
{
  if (theShape.IsNull())
  {
    throw Standard_NullObject("BRepCheck_Analyzer::Init() - NULL shape");
  }

  myShape = theShape;
  myMap.Clear();
  Put(theShape, B);
  Perform();
}

//=================================================================================================

void BRepCheck_Analyzer::Put(const TopoDS_Shape& theShape, const Standard_Boolean B)
{
  if (myMap.Contains(theShape))
  {
    return;
  }

  Handle(BRepCheck_Result) HR;
  switch (theShape.ShapeType())
  {
    case TopAbs_VERTEX:
      HR = new BRepCheck_Vertex(TopoDS::Vertex(theShape));
      break;
    case TopAbs_EDGE:
      HR = new BRepCheck_Edge(TopoDS::Edge(theShape));
      Handle(BRepCheck_Edge)::DownCast(HR)->GeometricControls(B);
      Handle(BRepCheck_Edge)::DownCast(HR)->SetExactMethod(myIsExact);
      break;
    case TopAbs_WIRE:
      HR = new BRepCheck_Wire(TopoDS::Wire(theShape));
      Handle(BRepCheck_Wire)::DownCast(HR)->GeometricControls(B);
      break;
    case TopAbs_FACE:
      HR = new BRepCheck_Face(TopoDS::Face(theShape));
      Handle(BRepCheck_Face)::DownCast(HR)->GeometricControls(B);
      break;
    case TopAbs_SHELL:
      HR = new BRepCheck_Shell(TopoDS::Shell(theShape));
      break;
    case TopAbs_SOLID:
      HR = new BRepCheck_Solid(TopoDS::Solid(theShape));
      break;
    case TopAbs_COMPSOLID:
    case TopAbs_COMPOUND:
      break;
    default:
      break;
  }

  if (!HR.IsNull())
  {
    HR->SetParallel(myIsParallel);
  }
  myMap.Add(theShape, HR);

  for (TopoDS_Iterator theIterator(theShape); theIterator.More(); theIterator.Next())
  {
    Put(theIterator.Value(), B); // performs minimum on each shape
  }
}

//=================================================================================================

void BRepCheck_Analyzer::Perform()
{
  const Standard_Integer        aMapSize     = myMap.Size();
  const Standard_Integer        aMinTaskSize = 10;
  const Handle(OSD_ThreadPool)& aThreadPool  = OSD_ThreadPool::DefaultPool();
  const Standard_Integer        aNbThreads   = aThreadPool->NbThreads();
  Standard_Integer              aNbTasks     = aNbThreads * 10;
  Standard_Integer              aTaskSize = (Standard_Integer)Ceiling((double)aMapSize / aNbTasks);
  if (aTaskSize < aMinTaskSize)
  {
    aTaskSize = aMinTaskSize;
    aNbTasks  = (Standard_Integer)Ceiling((double)aMapSize / aTaskSize);
  }

  NCollection_Array1<NCollection_Array1<TopoDS_Shape>> aArrayOfArray(0, aNbTasks - 1);
  for (Standard_Integer anI = 1; anI <= aMapSize; ++anI)
  {
    Standard_Integer aVectIndex  = (anI - 1) / aTaskSize;
    Standard_Integer aShapeIndex = (anI - 1) % aTaskSize;
    if (aShapeIndex == 0)
    {
      Standard_Integer aVectorSize = aTaskSize;
      Standard_Integer aTailSize   = aMapSize - aVectIndex * aTaskSize;
      if (aTailSize < aTaskSize)
      {
        aVectorSize = aTailSize;
      }
      aArrayOfArray[aVectIndex].Resize(0, aVectorSize - 1, Standard_False);
    }
    aArrayOfArray[aVectIndex][aShapeIndex] = myMap.FindKey(anI);
  }

  BRepCheck_ParallelAnalyzer aParallelAnalyzer(aArrayOfArray, myMap);
  OSD_Parallel::For(0, aArrayOfArray.Size(), aParallelAnalyzer, !myIsParallel);
}

//=================================================================================================

Standard_Boolean BRepCheck_Analyzer::IsValid(const TopoDS_Shape& S) const
{
  if (!myMap.FindFromKey(S).IsNull())
  {
    BRepCheck_ListIteratorOfListOfStatus itl;
    itl.Initialize(myMap.FindFromKey(S)->Status());
    if (itl.Value() != BRepCheck_NoError)
    { // a voir
      return Standard_False;
    }
  }

  for (TopoDS_Iterator theIterator(S); theIterator.More(); theIterator.Next())
  {
    if (!IsValid(theIterator.Value()))
    {
      return Standard_False;
    }
  }

  switch (S.ShapeType())
  {
    case TopAbs_EDGE: {
      return ValidSub(S, TopAbs_VERTEX);
    }
      //    break;
    case TopAbs_FACE: {
      Standard_Boolean valid = ValidSub(S, TopAbs_WIRE);
      valid                  = valid && ValidSub(S, TopAbs_EDGE);
      valid                  = valid && ValidSub(S, TopAbs_VERTEX);
      return valid;
    }

      //    break;
    case TopAbs_SHELL:
      //    return ValidSub(S,TopAbs_FACE);
      break;
    case TopAbs_SOLID:
      //    return ValidSub(S,TopAbs_EDGE);
      //    break;
      return ValidSub(S, TopAbs_SHELL);
      break;
    default:
      break;
  }

  return Standard_True;
}

//=================================================================================================

Standard_Boolean BRepCheck_Analyzer::ValidSub(const TopoDS_Shape&    S,
                                              const TopAbs_ShapeEnum SubType) const
{
  BRepCheck_ListIteratorOfListOfStatus itl;
  TopExp_Explorer                      exp;
  for (exp.Init(S, SubType); exp.More(); exp.Next())
  {
    //  for (TopExp_Explorer exp(S,SubType);exp.More(); exp.Next()) {
    const Handle(BRepCheck_Result)& RV = myMap.FindFromKey(exp.Current());
    for (RV->InitContextIterator(); RV->MoreShapeInContext(); RV->NextShapeInContext())
    {
      if (RV->ContextualShape().IsSame(S))
      {
        break;
      }
    }

    if (!RV->MoreShapeInContext())
      break;

    for (itl.Initialize(RV->StatusOnShape()); itl.More(); itl.Next())
    {
      if (itl.Value() != BRepCheck_NoError)
      {
        return Standard_False;
      }
    }
  }
  return Standard_True;
}