コード例 #1
0
ファイル: pytricall.py プロジェクト: arnaudbenard/triangle
def tricall0():
    import triIfaceUtils
    import triIfaceFileUtils
    #define some flags for how the script will run
    verbose = 2   #level of output
    tinfo = """triangulation:
number of points        = %d
attributes per point    = %d
number of triangles     = %d
nodes per triangle      = %d
attributes per triangle = %d
number of segments      = %d
number of holes         = %d
number of regions       = %d
number of edges         = %d
"""

    trin = triangulate.new()
    pointsin = Numeric.array([[0.0, 0.0],
                              [1.0,0.0],
                              [1.0,10.0],
                              [0.0,10.0]])
    npoints = pointsin.shape[0]
    pattsin = Numeric.array([0.0, 1.0, 11.0, 10.0])
    pmarkin = Numeric.zeros((npoints,),Numeric.Int)
    pmarkin[1] = 2
    pregion =  Numeric.array([[0.5,5.0,7.0,0.1]])
    if verbose > 3:
        print 'pregion shape=',pregion.shape
    #end verbose
    triangulate.setPointsAndMarkers(trin,pointsin,pmarkin)
    triangulate.setPointAttributes(trin,pattsin)
    triangulate.setRegions(trin,pregion)
    
    tiInfo = triangulate.getInfo(trin)

    print 'trin info says'
    print tinfo % tiInfo

    #create a simple flag list
    flags = "pczAevn"
    
    trimid = triangulate.new()
    vorout = triangulate.new()
    
    triangulate.applyTriangulate(flags,trin,trimid,vorout)

    tmInfo = triangulate.getInfo(trimid)

    print 'trimid info says'
    print tinfo % tmInfo

    if verbose > 1:
        points0 = triangulate.getPoints(trin)
        print 'in points=\n',points0
        elems0 = triangulate.getTriangles(trin)
        print 'in elems=\n',elems0
        elems1 = triangulate.getTriangles(trimid)
        print 'out elems=\n',elems1
    #end verbose
    if verbose > 1:
        print 'calling printReport for input'
        triangulate.printReport(trin)
        print 'calling printReport for output'
        triangulate.printReport(trimid)
    #end verbose
    triIfaceUtils.writeOutTriangulation(trimid,"trimesh")

    #now refine intermediate triangle
    nelmsmid = tmInfo[2]
    midArea = Numeric.zeros((nelmsmid,),Numeric.Float)
    midArea[0] = 3.0
    midArea[1] = 1.0

    triangulate.setTriangleAreas(trimid,midArea)
    
    triout = triangulate.new()
    flags  = "prazBP"
    triangulate.applyTriangulateNoVoronoi(flags,trimid,triout)
    
    triIfaceUtils.writeOutTriangulation(triout,"trimesh.1")


    #now view with showme
    showme = "../bin/showme"
    showmecmd = showme+" trimesh"

    failure = 0
    failure = triIfaceFileUtils.checkFileExists(showme)
    failure = os.system(showmecmd)
    
    #manually delete things for debugging
    print 'deleting trin'
    del trin
    print 'deleting trimid'
    del trimid
    print 'deleting vor'
    del vorout
    print 'deleting triout'
    del triout

    return failure
コード例 #2
0
    def convertToAdhPyUtilMesh(self, verbose=0):
        """
        Generate a representation in the format expected by
        adhPyUtil.

        Need to make sure the triangle mesh has generated
           nodes
           elements (triangles)
           edges
           neighbors
           
        First set the _global arrays for
            nodes
            elements
        """
        import MeshTools
        triInfo = triangulate.getInfo(self.trirep[0])
        if verbose > 1:
            print 'generating adhPyUtilMesh:'
            print self.infoFormat % triInfo
        #end if

        #create basic adhPyUtil mesh
        meshout = MeshTools.Mesh()

        #get basic information to make sure I can proceed
        #with current mesh representation
        nNodes_global = triInfo[0]
        nElems_global = triInfo[2]
        nNodes_elem = triInfo[3]
        nEdges_global = triInfo[8]
        spaceDim = 2
        assert (nNodes_global > 0 and nElems_global > 0 and nNodes_elem >= 3
                and nEdges_global > 0)

        #subtract off base since adhPyMesh wants base 0 more or less
        nbase = self.nbase
        #should also check? base zero,
        #get the minimum array information
        ##nodes
        nodeArray = triangulate.getPoints(self.trirep[0])
        meshout.nNodes_global = nNodes_global
        meshout.nodeArray = Numeric.zeros((meshout.nNodes_global, 3),
                                          Numeric.Float)
        for nN in range(nNodes_global):
            meshout.nodeArray[nN, :spaceDim] = nodeArray[nN, :spaceDim] - nbase
        ##elements
        elemArray = triangulate.getTriangles(self.trirep[0])
        #ignore higher order nodes for adhPyUtil mesh
        meshout.nNodes_element = spaceDim + 1
        meshout.nElements_global = nElems_global
        #just copy over first 3 nodes
        meshout.elementNodesArray = Numeric.zeros(
            (nElems_global, spaceDim + 1), Numeric.Int)
        for eN in range(nElems_global):
            meshout.elementNodesArray[eN, :] = elemArray[eN, :spaceDim +
                                                         1] - nbase
        #end eN

        ##adhPyMesh keeps elements per node
        nodeElementsDict = {}
        for eN in range(nElems_global):
            for nN_element in range(spaceDim + 1):
                nN = meshout.elementNodesArray[eN, nN_element]
                if nodeElementsDict.has_key(nN):
                    nodeElementsDict[nN].append(eN)
                else:
                    nodeElementsDict[nN] = [eN]
                #end if
            #end for nN_element
        #end eN
        meshout.max_nElements_node = max(
            len(nodeElementsDict[nN]) for nN in range(meshout.nNodes_global))

        meshout.nElements_node = Numeric.zeros((meshout.nNodes_global, ),
                                               Numeric.Int)
        meshout.nodeElementsArray = Numeric.zeros(
            (meshout.nNodes_global, meshout.max_nElements_node), Numeric.Int)
        for nN, elementList in nodeElementsDict.iteritems():
            meshout.nElements_node[nN] = len(elementList)
            for eN_element, eN in enumerate(elementList):
                meshout.nodeElementsArray[nN, eN_element] = eN
            #end eN_element
        #end nN

        ##now build the element <--> element boundary arrays
        meshout.nElementBoundaries_element = spaceDim + 1
        #make sure Triangle keeps all edges and not just boundary ones
        meshout.nElementBoundaries_global = nEdges_global

        #maps element, local edge number to global edge number
        meshout.elementBoundariesArray = Numeric.zeros(
            (nElems_global, spaceDim + 1), Numeric.Int)

        #maps edge to global element on left and right (out of domain is 0)
        meshout.elementBoundaryElementsArray = Numeric.ones(
            (meshout.nElementBoundaries_global, 2), Numeric.Int)
        meshout.elementBoundaryElementsArray *= -1
        #maps global edge to its local number on the neighboring elements
        meshout.elementBoundaryLocalElementBoundariesArray = Numeric.zeros(
            (meshout.nElementBoundaries_global, 2), Numeric.Int)

        #several options for edge to "left" and "right" element neighbor,
        #could number each neighbor according to which one
        #has a given edge first in the current numbering
        #could try to make element 0 be the one that has same orientation of edge

        elementBoundaryElementsCardArray = Numeric.zeros(
            (meshout.nElementBoundaries_global, ),
            Numeric.Int)  #CardArray in Mesh
        #I have to generate the element-->global edge number mapping manually
        edgeArray = triangulate.getEdges(self.trirep[0])
        edgeDict = {}
        for edgeN in range(nEdges_global):
            n0 = edgeArray[edgeN, 0] - nbase
            n1 = edgeArray[edgeN, 1] - nbase
            edgeDict[(n0, n1)] = edgeN  #global edge number
        #end for

        for eN in range(nElems_global):
            locNodes = elemArray[eN, :spaceDim +
                                 1] - nbase  #global node numbers
            edgeOrientedSame = [False, False, False]
            #edge I is across from node I
            #0
            e0 = (locNodes[1], locNodes[2])
            e0rev = (locNodes[2], locNodes[1])
            e0_global = None
            if edgeDict.has_key(e0):
                e0_global = edgeDict[e0]  #same orientation
                edgeOrientedSame[0] = True
            elif edgeDict.has_key(e0rev):  #opposite orientation
                e0_global = edgeDict[
                    e0rev]  #could make negative to denote orientation
            #end if
            assert (not e0_global == None)
            #1
            e1 = (locNodes[2], locNodes[0])
            e1rev = (locNodes[0], locNodes[2])
            e1_global = None
            if edgeDict.has_key(e1):
                e1_global = edgeDict[e1]  #same orientation
                edgeOrientedSame[1] = True
            elif edgeDict.has_key(e1rev):  #opposite orientation
                e1_global = edgeDict[
                    e1rev]  #could make negative to denote orientation
            #end if
            assert (not e1_global == None)
            #2
            e2 = (locNodes[0], locNodes[1])
            e2rev = (locNodes[1], locNodes[0])
            e2_global = None
            if edgeDict.has_key(e2):
                e2_global = edgeDict[e2]  #same orientation
                edgeOrientedSame[2] = True
            elif edgeDict.has_key(e2rev):  #opposite orientation
                e2_global = edgeDict[
                    e2rev]  #could make negative to denote orientation
            #end if
            assert (not e2_global == None)
            eI_global = Numeric.array([e0_global, e1_global, e2_global],
                                      Numeric.Int)
            meshout.elementBoundariesArray[eN, :] = eI_global
            for eI in eI_global:
                #edge --> element mappings
                elementBoundaryElementsCardArray[eI] += 1
            #end eI

            for eiloc in range(meshout.nElementBoundaries_element):
                eI = eI_global[eiloc]
                #first visited labelling
                elneig = elementBoundaryElementsCardArray[eI] - 1
                #elneig = 0 #same orientation
                #if not edgeOrientedSame[eiloc]
                #elneig = 1 #opposite
                ##endif
                meshout.elementBoundaryElementsArray[eI, elneig] = eN
                meshout.elementBoundaryLocalElementBoundariesArray[
                    eI, elneig] = eiloc
            #end eiloc
        #end eN

        #perform some sanity checks
        for edgeN in range(nEdges_global):
            assert (elementBoundaryElementsCardArray[edgeN] in [1, 2])
            eN0 = meshout.elementBoundaryElementsArray[edgeN, 0]
            eN1 = meshout.elementBoundaryElementsArray[edgeN, 1]
            assert (0 <= eN0 and eN0 < meshout.nElements_global)
            if elementBoundaryElementsCardArray[edgeN] == 1:
                assert (eN1 == -1)
            else:
                assert (0 <= eN1 and eN1 < meshout.nElements_global)
            #end if
        #end sanity check on edges
        #now take care of boundary edges
        #interior elements counted twice
        sumCard = Numeric.sum(elementBoundaryElementsCardArray)
        nExtBnd = 2 * meshout.nElementBoundaries_global - sumCard
        nIntBnd = meshout.nElementBoundaries_global - nExtBnd
        meshout.nExteriorElementBoundaries_global = nExtBnd
        meshout.nInteriorElementBoundaries_global = nIntBnd

        #global edge numbers on exterior boundary
        meshout.exteriorElementBoundariesArray = Numeric.zeros((nExtBnd, ),
                                                               Numeric.Int)
        meshout.interiorElementBoundariesArray = Numeric.zeros((nIntBnd, ),
                                                               Numeric.Int)

        #enumerate interior and exterior
        interiorI = 0
        exteriorI = 0
        for ebN in range(meshout.nElementBoundaries_global):
            if elementBoundaryElementsCardArray[ebN] == 1:
                meshout.exteriorElementBoundariesArray[exteriorI] = ebN
                exteriorI += 1
            else:
                meshout.interiorElementBoundariesArray[interiorI] = ebN
                interiorI += 1
            #end if on card
        #end ebN

        #now track which nodes are on the boundary
        #maps edge --> its nodes
        #this is just the edgelist in triangle
        meshout.elementBoundaryNodesArray = Numeric.zeros(
            (nEdges_global, spaceDim), Numeric.Int)
        for edgeN in range(nEdges_global):
            meshout.elementBoundaryNodesArray[
                edgeN, :spaceDim] = edgeArray[edgeN, :spaceDim] - nbase
        #end edgeN
        #2d so edgeList is same as elementBoundaryNodesArray
        meshout.edgeNodesArray = Numeric.zeros((nEdges_global, spaceDim),
                                               Numeric.Int)
        for edgeN in range(nEdges_global):
            meshout.edgeNodesArray[
                edgeN, :spaceDim] = edgeArray[edgeN, :spaceDim] - nbase
        #end edgeN

        #now tell mesh that it doesn't have the list interface
        meshout.hasListInterface = False
        #compute diameters array manually
        meshout.elementDiametersArray = Numeric.zeros(
            (meshout.nElements_global, ), Numeric.Float)
        import math
        for eN in range(meshout.nElements_global):
            elen = Numeric.zeros((meshout.nElementBoundaries_element, ),
                                 Numeric.Float)
            for eloc in range(meshout.nElementBoundaries_element):
                eg = meshout.elementBoundariesArray[eN,
                                                    eloc]  #glocal edge number
                n0, n1 = meshout.elementBoundaryNodesArray[
                    eg, 0:2]  #global node numbers number
                de = meshout.nodeArray[n0, :] - meshout.nodeArray[n1, :]
                elen[eloc] = math.sqrt(de[0]**2 + de[1]**2)
            #end eloc
            meshout.elementDiametersArray[eN] = max(elen)
        #end eN
        meshout.hasGeometricInfo = True
        return meshout
コード例 #3
0
ファイル: test.py プロジェクト: arnaudbenard/triangle
carea = Numeric.ones((nelem,),Numeric.Float)
print 'try to set triangle area constraints \n',carea
triangulate.setTriangleAreas(trin,carea)

#this should be empty before calling triangulate
neigs0 = triangulate.getNeighbors(trin)
print 'neigs= ',neigs0
#this should be empty before calling triangulate
neigs1 = triangulate.getNeighborsCopy(trin)
print 'neigsCopy= ',neigs1

vornorms= triangulate.getVoronoiNormals(trin)
print 'vornorms= ',vornorms

#get basic info about triangulation
info =triangulate.getInfo(trin)
sinfo = """triangulation:
number of points        = %d
attributes per point    = %d
number of triangles     = %d
nodes per triangle      = %d
attributes per triangle = %d
number of segments      = %d
number of holes         = %d
number of regions       = %d
number of edges         = %d
"""
print sinfo % info


#create a simple flag list
コード例 #4
0
    def convertToAdhPyUtilMesh(self,verbose=0):
        """
        Generate a representation in the format expected by
        adhPyUtil.

        Need to make sure the triangle mesh has generated
           nodes
           elements (triangles)
           edges
           neighbors
           
        First set the _global arrays for
            nodes
            elements
        """
        import MeshTools
        triInfo = triangulate.getInfo(self.trirep[0])
        if verbose > 1:
            print 'generating adhPyUtilMesh:'
            print self.infoFormat % triInfo
        #end if

        #create basic adhPyUtil mesh
        meshout = MeshTools.Mesh()

        #get basic information to make sure I can proceed
        #with current mesh representation
        nNodes_global = triInfo[0]; nElems_global = triInfo[2];
        nNodes_elem   = triInfo[3]; nEdges_global = triInfo[8];
        spaceDim      = 2
        assert(nNodes_global > 0 and nElems_global > 0
               and nNodes_elem >= 3 and nEdges_global > 0)

        #subtract off base since adhPyMesh wants base 0 more or less
        nbase = self.nbase
        #should also check? base zero, 
        #get the minimum array information
        ##nodes
        nodeArray = triangulate.getPoints(self.trirep[0])
        meshout.nNodes_global     = nNodes_global
        meshout.nodeArray = Numeric.zeros((meshout.nNodes_global,3),
                                          Numeric.Float)
        for nN in range(nNodes_global):
            meshout.nodeArray[nN,:spaceDim] = nodeArray[nN,:spaceDim]-nbase
        ##elements
        elemArray  = triangulate.getTriangles(self.trirep[0])
        #ignore higher order nodes for adhPyUtil mesh
        meshout.nNodes_element    = spaceDim+1
        meshout.nElements_global  = nElems_global
        #just copy over first 3 nodes
        meshout.elementNodesArray = Numeric.zeros((nElems_global,spaceDim+1),
                                                  Numeric.Int)
        for eN in range(nElems_global):
            meshout.elementNodesArray[eN,:] = elemArray[eN,:spaceDim+1]-nbase
        #end eN

        ##adhPyMesh keeps elements per node
        nodeElementsDict={}
        for eN in range(nElems_global):
            for nN_element in range(spaceDim+1):
                nN = meshout.elementNodesArray[eN,nN_element]
                if  nodeElementsDict.has_key(nN):
                    nodeElementsDict[nN].append(eN)
                else:
                    nodeElementsDict[nN] = [eN]
                #end if
            #end for nN_element
        #end eN
        meshout.max_nElements_node = max(len(nodeElementsDict[nN]) for nN in range(meshout.nNodes_global))

        meshout.nElements_node    = Numeric.zeros((meshout.nNodes_global,),Numeric.Int)
        meshout.nodeElementsArray = Numeric.zeros((meshout.nNodes_global,
                                                   meshout.max_nElements_node),
                                                  Numeric.Int)
        for nN,elementList in nodeElementsDict.iteritems():
            meshout.nElements_node[nN] = len(elementList)
            for eN_element,eN in enumerate(elementList):
                meshout.nodeElementsArray[nN,eN_element]=eN
            #end eN_element
        #end nN

        ##now build the element <--> element boundary arrays
        meshout.nElementBoundaries_element = spaceDim+1
        #make sure Triangle keeps all edges and not just boundary ones 
        meshout.nElementBoundaries_global  = nEdges_global 

        #maps element, local edge number to global edge number
        meshout.elementBoundariesArray = Numeric.zeros((nElems_global,spaceDim+1),
                                                       Numeric.Int)

        #maps edge to global element on left and right (out of domain is 0)
        meshout.elementBoundaryElementsArray=Numeric.ones(
            (meshout.nElementBoundaries_global,2),Numeric.Int)
        meshout.elementBoundaryElementsArray*=-1
        #maps global edge to its local number on the neighboring elements
        meshout.elementBoundaryLocalElementBoundariesArray=Numeric.zeros(
            (meshout.nElementBoundaries_global,2),Numeric.Int)

        #several options for edge to "left" and "right" element neighbor,
        #could number each neighbor according to which one
        #has a given edge first in the current numbering
        #could try to make element 0 be the one that has same orientation of edge

        elementBoundaryElementsCardArray = Numeric.zeros((meshout.nElementBoundaries_global,),
                                                         Numeric.Int) #CardArray in Mesh
        #I have to generate the element-->global edge number mapping manually
        edgeArray = triangulate.getEdges(self.trirep[0])
        edgeDict  = {}
        for edgeN in range(nEdges_global):
            n0 = edgeArray[edgeN,0]-nbase; n1 = edgeArray[edgeN,1]-nbase
            edgeDict[(n0,n1)] = edgeN #global edge number
        #end for
        
        for eN in range(nElems_global):
            locNodes = elemArray[eN,:spaceDim+1]-nbase #global node numbers
            edgeOrientedSame = [False,False,False]
            #edge I is across from node I
            #0
            e0 = (locNodes[1],locNodes[2]); e0rev = (locNodes[2],locNodes[1])
            e0_global = None
            if edgeDict.has_key(e0):
                e0_global = edgeDict[e0] #same orientation
                edgeOrientedSame[0] = True
            elif edgeDict.has_key(e0rev):     #opposite orientation
                e0_global = edgeDict[e0rev]   #could make negative to denote orientation
            #end if
            assert(not e0_global == None)
            #1
            e1 = (locNodes[2],locNodes[0]); e1rev = (locNodes[0],locNodes[2])
            e1_global = None
            if edgeDict.has_key(e1):
                e1_global = edgeDict[e1] #same orientation
                edgeOrientedSame[1] = True
            elif edgeDict.has_key(e1rev):     #opposite orientation
                e1_global = edgeDict[e1rev]   #could make negative to denote orientation
            #end if
            assert(not e1_global == None)
            #2
            e2 = (locNodes[0],locNodes[1]); e2rev = (locNodes[1],locNodes[0])
            e2_global = None
            if edgeDict.has_key(e2):
                e2_global = edgeDict[e2] #same orientation
                edgeOrientedSame[2] = True
            elif edgeDict.has_key(e2rev):     #opposite orientation
                e2_global = edgeDict[e2rev]   #could make negative to denote orientation
            #end if
            assert(not e2_global == None)
            eI_global = Numeric.array([e0_global,e1_global,e2_global],
                                      Numeric.Int)
            meshout.elementBoundariesArray[eN,:] = eI_global
            for eI in eI_global:
                #edge --> element mappings
                elementBoundaryElementsCardArray[eI] += 1
            #end eI

            
            for eiloc in range(meshout.nElementBoundaries_element):
                eI     = eI_global[eiloc]
                #first visited labelling
                elneig = elementBoundaryElementsCardArray[eI]-1
                #elneig = 0 #same orientation
                #if not edgeOrientedSame[eiloc]
                #elneig = 1 #opposite
                ##endif
                meshout.elementBoundaryElementsArray[eI,elneig]=eN
                meshout.elementBoundaryLocalElementBoundariesArray[eI,elneig]=eiloc
            #end eiloc
        #end eN

        #perform some sanity checks
        for edgeN in range(nEdges_global):
            assert(elementBoundaryElementsCardArray[edgeN] in [1,2])
            eN0 = meshout.elementBoundaryElementsArray[edgeN,0]
            eN1 = meshout.elementBoundaryElementsArray[edgeN,1]
            assert(0 <= eN0 and eN0 < meshout.nElements_global)
            if elementBoundaryElementsCardArray[edgeN] == 1:
                assert(eN1 == -1)
            else:
                assert(0 <= eN1 and eN1 < meshout.nElements_global)
            #end if
        #end sanity check on edges
        #now take care of boundary edges
        #interior elements counted twice
        sumCard = Numeric.sum(elementBoundaryElementsCardArray)
        nExtBnd = 2*meshout.nElementBoundaries_global-sumCard
        nIntBnd = meshout.nElementBoundaries_global-nExtBnd
        meshout.nExteriorElementBoundaries_global=nExtBnd
        meshout.nInteriorElementBoundaries_global=nIntBnd

        #global edge numbers on exterior boundary
        meshout.exteriorElementBoundariesArray=Numeric.zeros((nExtBnd,),Numeric.Int)
        meshout.interiorElementBoundariesArray=Numeric.zeros((nIntBnd,),Numeric.Int)

        #enumerate interior and exterior
        interiorI = 0
        exteriorI = 0
        for ebN in range(meshout.nElementBoundaries_global):
            if elementBoundaryElementsCardArray[ebN] == 1:
                meshout.exteriorElementBoundariesArray[exteriorI]=ebN
                exteriorI+= 1
            else:
                meshout.interiorElementBoundariesArray[interiorI]=ebN
                interiorI+= 1
            #end if on card
        #end ebN

        #now track which nodes are on the boundary
        #maps edge --> its nodes
        #this is just the edgelist in triangle
        meshout.elementBoundaryNodesArray = Numeric.zeros((nEdges_global,spaceDim),
                                                          Numeric.Int)
        for edgeN in range(nEdges_global):
            meshout.elementBoundaryNodesArray[edgeN,:spaceDim]=edgeArray[edgeN,:spaceDim]-nbase
        #end edgeN
        #2d so edgeList is same as elementBoundaryNodesArray
        meshout.edgeNodesArray = Numeric.zeros((nEdges_global,spaceDim),
                                               Numeric.Int)
        for edgeN in range(nEdges_global):
            meshout.edgeNodesArray[edgeN,:spaceDim]=edgeArray[edgeN,:spaceDim]-nbase
        #end edgeN

        #now tell mesh that it doesn't have the list interface
        meshout.hasListInterface=False
        #compute diameters array manually
        meshout.elementDiametersArray=Numeric.zeros((meshout.nElements_global,),
                                                    Numeric.Float)
        import math
        for eN in range(meshout.nElements_global):
            elen = Numeric.zeros((meshout.nElementBoundaries_element,),
                                 Numeric.Float)
            for eloc in range(meshout.nElementBoundaries_element):
                eg = meshout.elementBoundariesArray[eN,eloc] #glocal edge number
                n0,n1 = meshout.elementBoundaryNodesArray[eg,0:2] #global node numbers number
                de = meshout.nodeArray[n0,:]-meshout.nodeArray[n1,:]
                elen[eloc] = math.sqrt(de[0]**2 + de[1]**2)
            #end eloc
            meshout.elementDiametersArray[eN]=max(elen)
        #end eN
        meshout.hasGeometricInfo=True
        return meshout
コード例 #5
0
ファイル: test.py プロジェクト: govtmirror/triangle
carea = Numeric.ones((nelem, ), Numeric.Float)
print 'try to set triangle area constraints \n', carea
triangulate.setTriangleAreas(trin, carea)

#this should be empty before calling triangulate
neigs0 = triangulate.getNeighbors(trin)
print 'neigs= ', neigs0
#this should be empty before calling triangulate
neigs1 = triangulate.getNeighborsCopy(trin)
print 'neigsCopy= ', neigs1

vornorms = triangulate.getVoronoiNormals(trin)
print 'vornorms= ', vornorms

#get basic info about triangulation
info = triangulate.getInfo(trin)
sinfo = """triangulation:
number of points        = %d
attributes per point    = %d
number of triangles     = %d
nodes per triangle      = %d
attributes per triangle = %d
number of segments      = %d
number of holes         = %d
number of regions       = %d
number of edges         = %d
"""
print sinfo % info

#create a simple flag list
flags = "rzenqv"
コード例 #6
0
ファイル: pytricall.py プロジェクト: govtmirror/triangle
def tricall0():
    import triIfaceUtils
    import triIfaceFileUtils
    #define some flags for how the script will run
    verbose = 2  #level of output
    tinfo = """triangulation:
number of points        = %d
attributes per point    = %d
number of triangles     = %d
nodes per triangle      = %d
attributes per triangle = %d
number of segments      = %d
number of holes         = %d
number of regions       = %d
number of edges         = %d
"""

    trin = triangulate.new()
    pointsin = Numeric.array([[0.0, 0.0], [1.0, 0.0], [1.0, 10.0], [0.0,
                                                                    10.0]])
    npoints = pointsin.shape[0]
    pattsin = Numeric.array([0.0, 1.0, 11.0, 10.0])
    pmarkin = Numeric.zeros((npoints, ), Numeric.Int)
    pmarkin[1] = 2
    pregion = Numeric.array([[0.5, 5.0, 7.0, 0.1]])
    if verbose > 3:
        print 'pregion shape=', pregion.shape
    #end verbose
    triangulate.setPointsAndMarkers(trin, pointsin, pmarkin)
    triangulate.setPointAttributes(trin, pattsin)
    triangulate.setRegions(trin, pregion)

    tiInfo = triangulate.getInfo(trin)

    print 'trin info says'
    print tinfo % tiInfo

    #create a simple flag list
    flags = "pczAevn"

    trimid = triangulate.new()
    vorout = triangulate.new()

    triangulate.applyTriangulate(flags, trin, trimid, vorout)

    tmInfo = triangulate.getInfo(trimid)

    print 'trimid info says'
    print tinfo % tmInfo

    if verbose > 1:
        points0 = triangulate.getPoints(trin)
        print 'in points=\n', points0
        elems0 = triangulate.getTriangles(trin)
        print 'in elems=\n', elems0
        elems1 = triangulate.getTriangles(trimid)
        print 'out elems=\n', elems1
    #end verbose
    if verbose > 1:
        print 'calling printReport for input'
        triangulate.printReport(trin)
        print 'calling printReport for output'
        triangulate.printReport(trimid)
    #end verbose
    triIfaceUtils.writeOutTriangulation(trimid, "trimesh")

    #now refine intermediate triangle
    nelmsmid = tmInfo[2]
    midArea = Numeric.zeros((nelmsmid, ), Numeric.Float)
    midArea[0] = 3.0
    midArea[1] = 1.0

    triangulate.setTriangleAreas(trimid, midArea)

    triout = triangulate.new()
    flags = "prazBP"
    triangulate.applyTriangulateNoVoronoi(flags, trimid, triout)

    triIfaceUtils.writeOutTriangulation(triout, "trimesh.1")

    #now view with showme
    showme = "../bin/showme"
    showmecmd = showme + " trimesh"

    failure = 0
    failure = triIfaceFileUtils.checkFileExists(showme)
    failure = os.system(showmecmd)

    #manually delete things for debugging
    print 'deleting trin'
    del trin
    print 'deleting trimid'
    del trimid
    print 'deleting vor'
    del vorout
    print 'deleting triout'
    del triout

    return failure