ci fix

Author: mlemayTTE

geos-mesh/src/geos/mesh/model/CellTypeCounts.py

@@ -4,30 +4,30 @@
 import numpy as np
 import numpy.typing as npt
 from typing_extensions import Self
-from vtkmodules.vtkCommonDataModel import (
-    vtkCellTypes,
-    VTK_TRIANGLE, VTK_QUAD, VTK_TETRA, VTK_VERTEX, VTK_POLYHEDRON, VTK_POLYGON, VTK_PYRAMID, VTK_HEXAHEDRON, VTK_WEDGE, VTK_NUMBER_OF_CELL_TYPES
-)
-
+from vtkmodules.vtkCommonDataModel import ( vtkCellTypes, VTK_TRIANGLE, VTK_QUAD, VTK_TETRA, VTK_VERTEX, VTK_POLYHEDRON,
+                                            VTK_POLYGON, VTK_PYRAMID, VTK_HEXAHEDRON, VTK_WEDGE,
+                                            VTK_NUMBER_OF_CELL_TYPES )
 
 __doc__ = """
 CellTypeCounts stores the number of elements of each type.
 """
 
+
 class CellTypeCounts():
-    def __init__(self: Self ) ->None:
+
+    def __init__( self: Self ) -> None:
         """CellTypeCounts stores the number of cells of each type."""
-        self._counts: npt.NDArray[np.int64] = np.zeros(VTK_NUMBER_OF_CELL_TYPES, dtype=float)
+        self._counts: npt.NDArray[ np.int64 ] = np.zeros( VTK_NUMBER_OF_CELL_TYPES, dtype=float )
 
-    def __str__(self: Self) ->str:
+    def __str__( self: Self ) -> str:
         """Overload __str__ method.
 
         Returns:
             str: counts as string.
         """
         return self.print()
 
-    def __add__(self: Self, other :Self) ->Self:
+    def __add__( self: Self, other: Self ) -> Self:
         """Addition operator.
 
         CellTypeCounts addition consists in suming counts.
@@ -38,32 +38,32 @@ def __add__(self: Self, other :Self) ->Self:
         Returns:
             Self: new CellTypeCounts object
         """
-        assert isinstance(other, CellTypeCounts), "Other object must be a CellTypeCounts."
+        assert isinstance( other, CellTypeCounts ), "Other object must be a CellTypeCounts."
         newCounts: CellTypeCounts = CellTypeCounts()
         newCounts._counts = self._counts + other._counts
         return newCounts
 
-    def addType(self: Self, cellType: int) ->None:
+    def addType( self: Self, cellType: int ) -> None:
         """Increment the number of cell of input type.
 
         Args:
             cellType (int): cell type
         """
-        self._counts[cellType] += 1
-        self._updateGeneralCounts(cellType, 1)
+        self._counts[ cellType ] += 1
+        self._updateGeneralCounts( cellType, 1 )
 
-    def setTypeCount(self: Self, cellType: int, count: int) ->None:
+    def setTypeCount( self: Self, cellType: int, count: int ) -> None:
         """Set the number of cells of input type.
 
         Args:
             cellType (int): cell type
             count (int): number of cells
         """
-        prevCount = self._counts[cellType]
-        self._counts[cellType] = count
-        self._updateGeneralCounts(cellType, count - prevCount)
+        prevCount = self._counts[ cellType ]
+        self._counts[ cellType ] = count
+        self._updateGeneralCounts( cellType, count - prevCount )
 
-    def getTypeCount(self: Self, cellType: int)->int:
+    def getTypeCount( self: Self, cellType: int ) -> int:
         """Get the number of cells of input type.
 
         Args:
@@ -72,36 +72,36 @@ def getTypeCount(self: Self, cellType: int)->int:
         Returns:
             int: number of cells
         """
-        return int(self._counts[cellType])
+        return int( self._counts[ cellType ] )
 
-    def _updateGeneralCounts(self: Self, cellType: int, count: int) ->None:
+    def _updateGeneralCounts( self: Self, cellType: int, count: int ) -> None:
         """Update generic type counters.
 
         Args:
             cellType (int): cell type
             count (int): count increment
         """
-        if (cellType != VTK_POLYGON) and (vtkCellTypes.GetDimension(cellType) == 2):
-            self._counts[VTK_POLYGON] += count
-        if (cellType != VTK_POLYHEDRON) and (vtkCellTypes.GetDimension(cellType) == 3):
-            self._counts[VTK_POLYHEDRON] += count
+        if ( cellType != VTK_POLYGON ) and ( vtkCellTypes.GetDimension( cellType ) == 2 ):
+            self._counts[ VTK_POLYGON ] += count
+        if ( cellType != VTK_POLYHEDRON ) and ( vtkCellTypes.GetDimension( cellType ) == 3 ):
+            self._counts[ VTK_POLYHEDRON ] += count
 
-    def print(self: Self) ->str:
+    def print( self: Self ) -> str:
         """Print counts string.
 
         Returns:
             str: counts string.
         """
         card: str = ""
-        card +=  "|                                   |              |\n"
-        card +=  "|               -                   |       -      |\n"
+        card += "|                                   |              |\n"
+        card += "|               -                   |       -      |\n"
         card += f"| **Total Number of Vertices**      | {int(self._counts[VTK_VERTEX]):12} |\n"
         card += f"| **Total Number of Polygon**       | {int(self._counts[VTK_POLYGON]):12} |\n"
         card += f"| **Total Number of Polyhedron**    | {int(self._counts[VTK_POLYHEDRON]):12} |\n"
         card += f"| **Total Number of Cells**         | {int(self._counts[VTK_POLYHEDRON]+self._counts[VTK_POLYGON]):12} |\n"
-        card +=  "|               -                   |       -      |\n"
-        for cellType in (VTK_TRIANGLE, VTK_QUAD):
+        card += "|               -                   |       -      |\n"
+        for cellType in ( VTK_TRIANGLE, VTK_QUAD ):
             card += f"| **Total Number of {vtkCellTypes.GetClassNameFromTypeId(cellType):<13}** | {int(self._counts[cellType]):12} |\n"
-        for cellType in (VTK_TETRA, VTK_PYRAMID, VTK_WEDGE, VTK_HEXAHEDRON):
+        for cellType in ( VTK_TETRA, VTK_PYRAMID, VTK_WEDGE, VTK_HEXAHEDRON ):
             card += f"| **Total Number of {vtkCellTypes.GetClassNameFromTypeId(cellType):<13}** | {int(self._counts[cellType]):12} |\n"
         return card

geos-mesh/src/geos/mesh/processing/MergeColocatedPoints.py

@@ -19,7 +19,6 @@
     vtkCell,
 )
 
-
 __doc__ = """
 MergeColocatedPoints module is a vtk filter that merges colocated points from input mesh.
 
@@ -47,10 +46,12 @@
     output :vtkUnstructuredGrid = filter.GetOutputDataObject(0)
 """
 
-class MergeColocatedPoints(VTKPythonAlgorithmBase):
-    def __init__(self: Self ) ->None:
+
+class MergeColocatedPoints( VTKPythonAlgorithmBase ):
+
+    def __init__( self: Self ) -> None:
         """MergeColocatedPoints filter merges duplacted points of the input mesh."""
-        super().__init__(nInputPorts=1, nOutputPorts=1, outputType="vtkUnstructuredGrid")
+        super().__init__( nInputPorts=1, nOutputPorts=1, outputType="vtkUnstructuredGrid" )
 
     def FillInputPortInformation( self: Self, port: int, info: vtkInformation ) -> int:
         """Inherited from VTKPythonAlgorithmBase::RequestInformation.
@@ -63,13 +64,14 @@ def FillInputPortInformation( self: Self, port: int, info: vtkInformation ) -> i
             int: 1 if calculation successfully ended, 0 otherwise.
         """
         if port == 0:
-            info.Set(self.INPUT_REQUIRED_DATA_TYPE(), "vtkUnstructuredGrid")
-
-    def RequestDataObject(self: Self,
-                          request: vtkInformation,  # noqa: F841
-                          inInfoVec: list[ vtkInformationVector ],  # noqa: F841
-                          outInfoVec: vtkInformationVector,
-                         ) -> int:
+            info.Set( self.INPUT_REQUIRED_DATA_TYPE(), "vtkUnstructuredGrid" )
+
+    def RequestDataObject(
+        self: Self,
+        request: vtkInformation,  # noqa: F841
+        inInfoVec: list[ vtkInformationVector ],  # noqa: F841
+        outInfoVec: vtkInformationVector,
+    ) -> int:
         """Inherited from VTKPythonAlgorithmBase::RequestDataObject.
 
         Args:
@@ -80,19 +82,20 @@ def RequestDataObject(self: Self,
         Returns:
             int: 1 if calculation successfully ended, 0 otherwise.
         """
-        inData = self.GetInputData(inInfoVec, 0, 0)
-        outData = self.GetOutputData(outInfoVec, 0)
+        inData = self.GetInputData( inInfoVec, 0, 0 )
+        outData = self.GetOutputData( outInfoVec, 0 )
         assert inData is not None
-        if outData is None or (not outData.IsA(inData.GetClassName())):
+        if outData is None or ( not outData.IsA( inData.GetClassName() ) ):
             outData = inData.NewInstance()
-            outInfoVec.GetInformationObject(0).Set(outData.DATA_OBJECT(), outData)
-        return super().RequestDataObject(request, inInfoVec, outInfoVec)
-
-    def RequestData(self: Self,
-                    request: vtkInformation,  # noqa: F841
-                    inInfoVec: list[ vtkInformationVector ],  # noqa: F841
-                    outInfoVec: vtkInformationVector,
-                   ) -> int:
+            outInfoVec.GetInformationObject( 0 ).Set( outData.DATA_OBJECT(), outData )
+        return super().RequestDataObject( request, inInfoVec, outInfoVec )
+
+    def RequestData(
+        self: Self,
+        request: vtkInformation,  # noqa: F841
+        inInfoVec: list[ vtkInformationVector ],  # noqa: F841
+        outInfoVec: vtkInformationVector,
+    ) -> int:
         """Inherited from VTKPythonAlgorithmBase::RequestData.
 
         Args:
@@ -104,17 +107,14 @@ def RequestData(self: Self,
             int: 1 if calculation successfully ended, 0 otherwise.
         """
         inData: vtkUnstructuredGrid = vtkUnstructuredGrid.GetData( inInfoVec[ 0 ] )
-        output: vtkUnstructuredGrid = self.GetOutputData(outInfoVec, 0)
+        output: vtkUnstructuredGrid = self.GetOutputData( outInfoVec, 0 )
         assert inData is not None, "Input mesh is undefined."
         assert output is not None, "Output mesh is undefined."
-        vertexMap: list[int] = self.setMergePoints(inData, output)
-        self.setCells(inData, output, vertexMap)
+        vertexMap: list[ int ] = self.setMergePoints( inData, output )
+        self.setCells( inData, output, vertexMap )
         return 1
 
-    def setMergePoints(self :Self,
-                       input: vtkUnstructuredGrid,
-                       output: vtkUnstructuredGrid
-                      ) ->list[int]:
+    def setMergePoints( self: Self, input: vtkUnstructuredGrid, output: vtkUnstructuredGrid ) -> list[ int ]:
         """Merge duplicated points and set new points and attributes to output mesh.
 
         Args:
@@ -124,36 +124,33 @@ def setMergePoints(self :Self,
         Returns:
             list[int]: list containing new point ids.
         """
-        vertexMap: list[int] = []
+        vertexMap: list[ int ] = []
         newPoints: vtkPoints = vtkPoints()
         # use point locator to check for colocated points
         pointsLocator = vtkIncrementalOctreePointLocator()
-        pointsLocator.InitPointInsertion(newPoints,input.GetBounds())
+        pointsLocator.InitPointInsertion( newPoints, input.GetBounds() )
         # create an array to count the number of colocated points
         vertexCount: vtkIntArray = vtkIntArray()
-        vertexCount.SetName("Count")
-        ptId = reference(0)
-        countD: int = 0 # total number of colocated points
-        for v in range(input.GetNumberOfPoints()):
-            inserted: bool = pointsLocator.InsertUniquePoint( input.GetPoints().GetPoint(v), ptId)
+        vertexCount.SetName( "Count" )
+        ptId = reference( 0 )
+        countD: int = 0  # total number of colocated points
+        for v in range( input.GetNumberOfPoints() ):
+            inserted: bool = pointsLocator.InsertUniquePoint( input.GetPoints().GetPoint( v ), ptId )
             if inserted:
-                vertexCount.InsertNextValue(1)
+                vertexCount.InsertNextValue( 1 )
             else:
-                vertexCount.SetValue( ptId, vertexCount.GetValue(ptId) + 1)
+                vertexCount.SetValue( ptId, vertexCount.GetValue( ptId ) + 1 )
                 countD = countD + 1
-            vertexMap += [ptId.get()]
+            vertexMap += [ ptId.get() ]
 
-        output.SetPoints(pointsLocator.GetLocatorPoints())
+        output.SetPoints( pointsLocator.GetLocatorPoints() )
         # copy point attributes
-        output.GetPointData().DeepCopy(input.GetPointData())
+        output.GetPointData().DeepCopy( input.GetPointData() )
         # add the array to points data
-        output.GetPointData().AddArray(vertexCount)
+        output.GetPointData().AddArray( vertexCount )
         return vertexMap
 
-    def setCells(self :Self,
-                 input: vtkUnstructuredGrid,
-                 output: vtkUnstructuredGrid,
-                 vertexMap: list[int]) ->bool:
+    def setCells( self: Self, input: vtkUnstructuredGrid, output: vtkUnstructuredGrid, vertexMap: list[ int ] ) -> bool:
         """Set cell point ids and attributes to output mesh.
 
         Args:
@@ -166,21 +163,22 @@ def setCells(self :Self,
         """
         nbCells: int = input.GetNumberOfCells()
         nbPoints: int = output.GetNumberOfPoints()
-        assert np.unique(vertexMap).size == nbPoints, "The size of the list of point ids must be equal to the number of points."
+        assert np.unique(
+            vertexMap ).size == nbPoints, "The size of the list of point ids must be equal to the number of points."
         cellTypes: vtkCellTypes = vtkCellTypes()
-        input.GetCellTypes(cellTypes)
-        output.Allocate(nbCells)
+        input.GetCellTypes( cellTypes )
+        output.Allocate( nbCells )
         # create mesh cells
-        for cellId in range(nbCells):
-            cell: vtkCell = input.GetCell(cellId)
+        for cellId in range( nbCells ):
+            cell: vtkCell = input.GetCell( cellId )
             # create cells from point ids
             cellsID: vtkIdList = vtkIdList()
-            for ptId in range(cell.GetNumberOfPoints()):
-                ptIdOld: int = cell.GetPointId(ptId)
-                ptIdNew: int = vertexMap[ptIdOld]
-                cellsID.InsertNextId(ptIdNew)
-            output.InsertNextCell(cell.GetCellType(), cellsID)
+            for ptId in range( cell.GetNumberOfPoints() ):
+                ptIdOld: int = cell.GetPointId( ptId )
+                ptIdNew: int = vertexMap[ ptIdOld ]
+                cellsID.InsertNextId( ptIdNew )
+            output.InsertNextCell( cell.GetCellType(), cellsID )
         # copy cell attributes
         assert output.GetNumberOfCells() == nbCells, "Output and input mesh must have the same number of cells."
-        output.GetCellData().DeepCopy(input.GetCellData())
+        output.GetCellData().DeepCopy( input.GetCellData() )
         return True