예제 #1
0
    def __init__(self,baseFlags="zen",nbase=0,verbose=0):
        """
        initialize the triangulation object,
        keep track of what numbering scheme it uses,
        create a base set of flags for triangulate (e.g., z if using base 0)

        does not create a Voronoi diagram by default
        """
        self.trirep = []
        self.trirep.append(triangleWrappers.new())
        self.trirepDefaultInit = []
        self.trirepDefaultInit.append(True)
        self.vorrep = []
        self.vorrep.append(triangleWrappers.new()) #don't create a Voronoi diagram by default
        self.makeVoronoi = False
        self.vorrepDefaultInit = []
        self.vorrepDefaultInit.append(True)
        assert(nbase in [0,1])
        self.nbase  = nbase
        self.baseFlags = baseFlags
        if self.nbase == 0 and self.baseFlags.find('z') == -1:
            print """WARNING TriangleMesh base numbering= %d
            reqires z in baseFlags = %s, adding """ % (self.nbase,self.baseFlags)
            self.baseFlags += "z"
        #end if
        if self.baseFlags.find('v') >= 0:
            self.makeVoronoi = True
        if verbose > 0:
            logEvent("""TriangleBaseMesh nbase=%d baseFlags= %s """ % (self.nbase,
                                                                    self.baseFlags))
        #end if
        #keep track of last set of flags used to generate rep
        self.lastFlags = None
        #to make printing out info easier
        self.infoFormat = """triangulation:
예제 #2
0
    def resetDefaultTrirep(self,index=0,verbose=0):
        """
        reset the Triangle mesh representation if it has been set to something nontrivial

        """
        assert(index in range(0,len(self.trirep)))
        #delete the existing representation if it has been initialized
        if not self.trirepDefaultInit[index]:
            if verbose > -1:
                logEvent('TriangleIface deleting current trirep[',index,']')
            #end verbose
            del self.trirep[index]
            #get a new represenation
            if index == 0:
                self.trirep.append(triangleWrappers.new())
            else:
                self.trirep[index] = triangleWrappers.new()
            self.trirepDefaultInit[index] = True
예제 #3
0
    def convertFromProteusMesh(self,meshin,verbose=0):
        """
        generate a Triangle mesh representation from an proteus mesh.
        This version will copy over the nodes and elements from the
        proteus mesh.

        Deletes the existing Triangle mesh and regenerates.
        """

        #first check that the input mesh has the correct dimensions and
        #minimal information necessary
        spaceDim = 2
        assert(meshin.nElementBoundaries_element == spaceDim+1)
        assert(meshin.nodeArray is not None)
        assert(meshin.elementNodesArray is not None)

        #get a clean slate
        tri0 = triangleWrappers.new()
        #don't set any markers for now
        #input array should be nNodes by spacedim
        nodesIn = meshin.nodeArray[:,:spaceDim]
        triangleWrappers.setPoints(tri0,nodesIn)
        #triangle array should be nElements x 3
        triAin  = meshin.elementNodesArray[:,:spaceDim+1]
        triangleWrappers.setTriangles(tri0,triAin)

        flagsAdd = "r" #use element and node connections
        flags = flagsAdd+self.baseFlags
        if flags.find('v') >= 0:
            self.makeVoronoi = True
            if verbose > 0:
                logEvent('readNodeAndEle makeVoronoi= ',self.makeVoronoi,' flags= ',flags)
        #end if
        self.lastFlags = flags
        #reset data representations if necessary
        self.resetDefaultTrirep(index=0,verbose=verbose)
        if self.makeVoronoi:
            self.resetDefaultVorrep(index=0,verbose=verbose)
        #end vorrep initialized

        if self.makeVoronoi:
            triangleWrappers.applyTriangulate(flags,tri0,self.trirep[0],self.vorrep[0])
            #handles no longer contain trivial representations
            self.trirepDefaultInit[0] = False
            self.vorrepDefaultInit[0] = False

        else:
            triangleWrappers.applyTriangulateNoVoronoi(flags,tri0,self.trirep[0])
            #handle no longer contains trivial representations
            self.trirepDefaultInit[0] = False
        #end if

        #clean up explicitly
        del tri0
예제 #4
0
def testGenerateTriangulationFromPointSet(points):
    """
    input: point-set

    generate triangle representation of the points

    output: an array contaning the points, and element to Node connectivity
    """
    #mwf debug
    #import pdb
    #pdb.set_trace()
    #default representation for holding input points
    tri0 = triangleWrappers.new()

    triangleWrappers.setPoints(tri0,points[:,:2])

    flags = "qz" #just use simple quality mesh generation, number from zero

    #default representation for holding output points
    tri1 = triangleWrappers.new()

    triangleWrappers.applyTriangulateNoVoronoi(flags,tri0,tri1)

    #if returning nodeArray and elementNodesArray outside of routine
    #use getPointsCopy, getTrianglesCopy
    #otherwise if doing all the necessary generation of quadrature points
    #and weights internally don't need deep copy
    nodeArray2d = triangleWrappers.getPointsCopy(tri1)
    elementNodesArray = triangleWrappers.getTrianglesCopy(tri1)



    #clean up
    del tri0
    del tri1

    return nodeArray2d,elementNodesArray
예제 #5
0
 def resetDefaultVorrep(self,index=0,verbose=0):
     """
     reset the Triangle mesh Voronoi representation if it has
     been set to something nontrivial
     """
     assert(index in range(0,len(self.vorrep)))
     #delete the existing representation if it has been initialized
     if not self.vorrepDefaultInit[index]:
         if verbose > -1:
             print 'TriangleIface deleting current vorrep[',index,']'
         #end verbose
         del self.vorrep[index]
         #get a new represenation
         self.vorrep[index] = triangleWrappers.new()
         self.vorrepDefaultInit[index] = True
예제 #6
0
    def readFromPolyFile(self,filebase,flagsAdd="",verbose=0):
        """Reads in the triangle representation from filebase.poly file.

        Parameters
        ----------
        filebase : str
            The filename with the triangluation.
        flagsAdd : str
        verbose : int
            A flag indicating how much information to pipe to stdout.

        Notes
        -----
        Function assumes the nbase data member is set appropriately.
        """
        reader = TriangleUtils.TriangleInputFileReader()
        if verbose > 0:
            logEvent('readFromPolyFile filebase= ',filebase)
        #end if

        polyDataInfo,polyData = reader.readPoly(filebase,nbase=self.nbase,
                                                verbose=verbose)

        if verbose > 3:
            for type in ['node','segment','hole','region']:
                logEvent('Poly: ',type,'Info= \n',polyDataInfo[type],'\n')
            #end for
        #end if

        nodes,nodesA,nodesM = (polyData['node']['nodes'],
                               polyData['node']['nodeAttributes'],
                               polyData['node']['nodeMarkers'])
        segments,segmentsM   = (polyData['segment']['segments'],
                                polyData['segment']['segmentMarkers'])
        holes                 = polyData['hole']['holes']
        regions               = polyData['region']['regions']

        if verbose > 3:
            logEvent("""Poly file read:
            nodes   = \n%s\n nodeAttributes= \n%s\n nodeMarkers= \n%s\n
            segments= \n%s\n segmentMarkers= \n%s\n
            holes   = \n%s\n
            regions = \n%s\n
            """ % (nodes,nodesA,nodesM,segments,segmentsM,holes,regions))
        #end if
        tri0 = triangleWrappers.new()

        if nodesM is None:
            triangleWrappers.setPoints(tri0,nodes)
        else:
            nodesMtmp = numpy.zeros(nodesM.shape,'i')
            nodesMtmp[:] = nodesM
            nodesM = nodesMtmp
            triangleWrappers.setPointsAndMarkers(tri0,nodes,nodesM)
        if nodesA is not None:
            triangleWrappers.setPointAttributes(tri0,nodesA)
        #end if
        if segmentsM is None:
            triangleWrappers.setSegments(tri0,segments)
        else:
            triangleWrappers.setSegmentsAndMarkers(tri0,segments,segmentsM)
        #end if
        if (holes is not None):
            triangleWrappers.setHoles(tri0,holes)
        #end if
        if (regions is not None):
            #print 'setting trin1 regions=\n',regions2
            triangleWrappers.setRegions(tri0,regions)
        #end if

        flags = flagsAdd+self.baseFlags
        if flags.find('p') == -1:
            logEvent('flags = ',flags,' must have p, appending')
            flags += "p"
        #end
        if flags.find('v') >= 0:
            self.makeVoronoi = True
            if verbose > 0:
                logEvent('readNodeAndEle makeVoronoi= ',self.makeVoronoi,' flags= ',flags)
        #end if
        self.lastFlags = flags
        #reset data representations if necessary
        self.resetDefaultTrirep(index=0,verbose=verbose)
        if self.makeVoronoi:
            self.resetDefaultVorrep(index=0,verbose=verbose)
        #end vorrep initialized

        if self.makeVoronoi:
            triangleWrappers.applyTriangulate(flags,tri0,self.trirep[0],self.vorrep[0])
            #handles no longer contain trivial representations
            self.trirepDefaultInit[0] = False
            self.vorrepDefaultInit[0] = False
        else:
            triangleWrappers.applyTriangulateNoVoronoi(flags,tri0,self.trirep[0])
            #handle no longer contains trivial representations
            self.trirepDefaultInit[0] = False
        #end if

        #clean up?
        del tri0
예제 #7
0
    def readFromNodeAndEleFiles(self,filebase,flagsAdd="",verbose=0):
        """
        read triangle representation from filebase.node and filebase.ele
        files. assumes the nbase data member is set appropriately
        """
        reader = TriangleUtils.TriangleInputFileReader()
        if verbose > 0:
            logEvent('readFromNodeAndEleFiles filebase= ',filebase)
        #end if
        nodeDataInfo,nodeData = reader.readNodes(filebase,nbase=self.nbase)
        nodes,nodesA,nodesM = (nodeData['nodes'],
                               nodeData['nodeAttributes'],
                               nodeData['nodeMarkers'])

        if verbose > 3:
            logEvent('Nodes: nodeInfo= ',nodeDataInfo)
            logEvent("""Nodes: nodes= \n%s\n nodeAttributes= \n%s\n nodeMarkers= \n%s
            """ % (nodes,nodesA,nodesM))
        #end if

        triDataInfo,triData = reader.readTriangles(filebase,nbase=self.nbase)
        triangles,trianglesA = triData['triangles'],triData['triangleAttributes']

        if verbose > 3:
            logEvent('Triangles: triInfo= ',triDataInfo)
            logEvent("""Triangles: elems= \n%s\n triAttributes= \n%s
            """ % (triangles,trianglesA))
        #end if

        #now create an initial representation
        tri0 = triangleWrappers.new()

        if nodesM is None:
            triangleWrappers.setPoints(tri0,nodes)
        else:
            triangleWrappers.setPointsAndMarkers(tri0,nodes,nodesM)
        if nodesA is not None:
            triangleWrappers.setPointAttributes(tri0,nodesA)
        #end if

        triangleWrappers.setTriangles(tri0,triangles)
        if trianglesA is not None:
            triangleWrappers.setTriangleAttributes(tri0,trianglesA)

        #run triangulate on it using the base flags and whatever else was
        #added
        flags = flagsAdd+self.baseFlags
        if flags.find('v') >= 0:
            self.makeVoronoi = True
            if verbose > 0:
                logEvent('readNodeAndEle makeVoronoi= ',self.makeVoronoi,' flags= ',flags)
        #end if
        self.lastFlags = flags

        #reset data representations if necessary
        self.resetDefaultTrirep(index=0,verbose=verbose)
        if self.makeVoronoi:
            self.resetDefaultVorrep(index=0,verbose=verbose)
        #end vorrep initialized

        if self.makeVoronoi:
            triangleWrappers.applyTriangulate(flags,tri0,self.trirep[0],self.vorrep[0])
            #handles no longer contain trivial representations
            self.trirepDefaultInit[0] = False
            self.vorrepDefaultInit[0] = False
        else:
            triangleWrappers.applyTriangulateNoVoronoi(flags,tri0,self.trirep[0])
            #handle no longer contains trivial representations
            self.trirepDefaultInit[0] = False
        #end if

        #do I need to clean up explicitly?
        del tri0
예제 #8
0
def testGenerateSSIPtriangulation(points):
    """
    input: vertices and SSIP points belonging to a single element

    generate triangle representation of the points

    output: an array contaning the points, and element quadrature weights for the points

    test with input
import numpy
from proteus import TriangleTools
points = numpy.array([[0.0,0.0,0.0],[0.5,0.4,0.],[1.0,0.0,0.0],[0.2,0.3,0.0],[0.0,1.0,0.0]])
dV,x = TriangleTools.testGenerateSSIPtriangulation(points)

    """
    #mwf debug
    #import pdb
    #pdb.set_trace()
    #default representation for holding input points
    tri0 = triangleWrappers.new()

    triangleWrappers.setPoints(tri0,points[:,:2])

    flags = "z"#"qz" #just use simple quality mesh generation, number from zero

    #default representation for holding output points
    tri1 = triangleWrappers.new()

    triangleWrappers.applyTriangulateNoVoronoi(flags,tri0,tri1)

    #doing all the necessary generation of quadrature points
    #and weights internally don't need deep copy
    nodeArray2d = triangleWrappers.getPoints(tri1)
    elementNodesArray = triangleWrappers.getTriangles(tri1)

    import Quadrature,cfemIntegrals
    #try Gauss quadrature different orders
    #subElementQuadrature = Quadrature.GaussTriangle()
    #subElementQuadrature.setOrder(2)  #order(1)
    #What about vertex quadrature
    subElementQuadrature = Quadrature.LobattoTriangle()
    subElementQuadrature.setOrder(3)

    nSubQuadraturePoints = len(subElementQuadrature.weights)
    nElements = elementNodesArray.shape[0]
    nQuadraturePoints = nElements*nSubQuadraturePoints
    nSpace = 2
    nDOF_element = 3
    weights_ref = numpy.array(subElementQuadrature.weights)
    points_ref  = numpy.array(subElementQuadrature.points)
    #loop through elements, compute area, map reference points to physical space,
    #and compute physical space weights

    #to be consistent need to have nodes be 3d
    nodeArray = numpy.zeros((nodeArray2d.shape[0],3),'d')
    nodeArray[:,0:2] = nodeArray2d
    #need to store psi and grad_psi to avoid recalculating across a lot of elements?
    #shape functions  are 1-x-y, x, y
    psi = numpy.zeros((nSubQuadraturePoints,nDOF_element),'d')
    psi[:,0] = 1.0-points_ref[:,0]-points_ref[:,1]
    psi[:,1] = points_ref[:,0]
    psi[:,2] = points_ref[:,1]
    #for k in range(nSubQuadraturePoints):
    #    psi[k,0] = 1.0-subElementQuadrature.points[k][0]-subElementQuadrature.points[k][1]
    #    psi[k,1] = subElementQuadrature.points[k][0]
    #    psi[k,2] = subElementQuadrature.points[k][1]
    grad_psi = numpy.zeros((nSubQuadraturePoints,nDOF_element,nSpace),'d')
    #shape functions  are 1-x-y, x, y
    grad_psi[:,0,0].fill(-1.); grad_psi[:,0,1].fill(-1.)
    grad_psi[:,1,0].fill(1.0);
    grad_psi[:,2,1].fill(1.0)
    #waste space to reuse code
    jacobianArray    = numpy.zeros((nElements,nSubQuadraturePoints,nSpace,nSpace),'d')
    jacobianDetArray = numpy.zeros((nElements,nSubQuadraturePoints),'d')
    jacobianInvArray = numpy.zeros((nElements,nSubQuadraturePoints,nSpace,nSpace),'d')

    cfemIntegrals.parametricMaps_getJacobianValues(grad_psi,
                                                   elementNodesArray,
                                                   nodeArray,
                                                   jacobianArray,
                                                   jacobianDetArray,
                                                   jacobianInvArray)


    jacobianDetArrayAbs = numpy.absolute(jacobianDetArray)
    #weights and points shaped like nSubElements x nQuadraturePointsSubElement
    q_sub_dV = numpy.zeros((nElements,nSubQuadraturePoints),'d')
    q_sub_x  = numpy.zeros((nElements,nSubQuadraturePoints,3),'d')

    cfemIntegrals.calculateIntegrationWeights(jacobianDetArrayAbs,
                                              weights_ref,
                                              q_sub_dV)

    cfemIntegrals.parametricMaps_getValues(psi,
                                           elementNodesArray,
                                           nodeArray,
                                           q_sub_x)


    #clean up
    del tri0
    del tri1

    #exit
    return q_sub_dV,q_sub_x
예제 #9
0
    def readFromNodeAndEleFiles(self,filebase,flagsAdd="",verbose=0):
        """
        read triangle representation from filebase.node and filebase.ele
        files. assumes the nbase data member is set appropriately
        """
        reader = TriangleUtils.TriangleInputFileReader()
        if verbose > 0:
            print 'readFromNodeAndEleFiles filebase= ',filebase
        #end if
        nodeDataInfo,nodeData = reader.readNodes(filebase,nbase=self.nbase)
        nodes,nodesA,nodesM = (nodeData['nodes'],
                               nodeData['nodeAttributes'],
                               nodeData['nodeMarkers'])

        if verbose > 3:
            print 'Nodes: nodeInfo= ',nodeDataInfo
            print """Nodes: nodes= \n%s\n nodeAttributes= \n%s\n nodeMarkers= \n%s
            """ % (nodes,nodesA,nodesM)
        #end if

        triDataInfo,triData = reader.readTriangles(filebase,nbase=self.nbase)
        triangles,trianglesA = triData['triangles'],triData['triangleAttributes']

        if verbose > 3:
            print 'Triangles: triInfo= ',triDataInfo
            print """Triangles: elems= \n%s\n triAttributes= \n%s
            """ % (triangles,trianglesA)
        #end if

        #now create an initial representation
        tri0 = triangleWrappers.new()

        if nodesM is None:
            triangleWrappers.setPoints(tri0,nodes)
        else:
            triangleWrappers.setPointsAndMarkers(tri0,nodes,nodesM)
        if nodesA is not None:
            triangleWrappers.setPointAttributes(tri0,nodesA)
        #end if

        triangleWrappers.setTriangles(tri0,triangles)
        if trianglesA is not None:
            triangleWrappers.setTriangleAttributes(tri0,trianglesA)

        #run triangulate on it using the base flags and whatever else was
        #added
        flags = flagsAdd+self.baseFlags
        if flags.find('v') >= 0:
            self.makeVoronoi = True
            if verbose > 0:
                print 'readNodeAndEle makeVoronoi= ',self.makeVoronoi,' flags= ',flags
        #end if
        self.lastFlags = flags

        #reset data representations if necessary
        self.resetDefaultTrirep(index=0,verbose=verbose)
        if self.makeVoronoi:
            self.resetDefaultVorrep(index=0,verbose=verbose)
        #end vorrep initialized

        if self.makeVoronoi:
            triangleWrappers.applyTriangulate(flags,tri0,self.trirep[0],self.vorrep[0])
            #handles no longer contain trivial representations
            self.trirepDefaultInit[0] = False
            self.vorrepDefaultInit[0] = False
        else:
            triangleWrappers.applyTriangulateNoVoronoi(flags,tri0,self.trirep[0])
            #handle no longer contains trivial representations
            self.trirepDefaultInit[0] = False
        #end if

        #do I need to clean up explicitly?
        del tri0
예제 #10
0
def testGenerateSSIPtriangulation(points):
    """
    input: vertices and SSIP points belonging to a single element

    generate triangle representation of the points

    output: an array contaning the points, and element quadrature weights for the points

    test with input
import numpy
from proteus import TriangleTools
points = numpy.array([[0.0,0.0,0.0],[0.5,0.4,0.],[1.0,0.0,0.0],[0.2,0.3,0.0],[0.0,1.0,0.0]])
dV,x = TriangleTools.testGenerateSSIPtriangulation(points)

    """
    #mwf debug
    #import pdb
    #pdb.set_trace()
    #default representation for holding input points
    tri0 = triangleWrappers.new()

    triangleWrappers.setPoints(tri0,points[:,:2])

    flags = "z"#"qz" #just use simple quality mesh generation, number from zero

    #default representation for holding output points
    tri1 = triangleWrappers.new()

    triangleWrappers.applyTriangulateNoVoronoi(flags,tri0,tri1)

    #doing all the necessary generation of quadrature points
    #and weights internally don't need deep copy
    nodeArray2d = triangleWrappers.getPoints(tri1)
    elementNodesArray = triangleWrappers.getTriangles(tri1)

    import Quadrature,cfemIntegrals
    #try Gauss quadrature different orders
    #subElementQuadrature = Quadrature.GaussTriangle()
    #subElementQuadrature.setOrder(2)  #order(1)
    #What about vertex quadrature
    subElementQuadrature = Quadrature.LobattoTriangle()
    subElementQuadrature.setOrder(3)

    nSubQuadraturePoints = len(subElementQuadrature.weights)
    nElements = elementNodesArray.shape[0]
    nQuadraturePoints = nElements*nSubQuadraturePoints
    nSpace = 2
    nDOF_element = 3
    weights_ref = numpy.array(subElementQuadrature.weights)
    points_ref  = numpy.array(subElementQuadrature.points)
    #loop through elements, compute area, map reference points to physical space,
    #and compute physical space weights

    #to be consistent need to have nodes be 3d
    nodeArray = numpy.zeros((nodeArray2d.shape[0],3),'d')
    nodeArray[:,0:2] = nodeArray2d
    #need to store psi and grad_psi to avoid recalculating across a lot of elements?
    #shape functions  are 1-x-y, x, y
    psi = numpy.zeros((nSubQuadraturePoints,nDOF_element),'d')
    psi[:,0] = 1.0-points_ref[:,0]-points_ref[:,1]
    psi[:,1] = points_ref[:,0]
    psi[:,2] = points_ref[:,1]
    #for k in range(nSubQuadraturePoints):
    #    psi[k,0] = 1.0-subElementQuadrature.points[k][0]-subElementQuadrature.points[k][1]
    #    psi[k,1] = subElementQuadrature.points[k][0]
    #    psi[k,2] = subElementQuadrature.points[k][1]
    grad_psi = numpy.zeros((nSubQuadraturePoints,nDOF_element,nSpace),'d')
    #shape functions  are 1-x-y, x, y
    grad_psi[:,0,0].fill(-1.); grad_psi[:,0,1].fill(-1.)
    grad_psi[:,1,0].fill(1.0);
    grad_psi[:,2,1].fill(1.0)
    #waste space to reuse code
    jacobianArray    = numpy.zeros((nElements,nSubQuadraturePoints,nSpace,nSpace),'d')
    jacobianDetArray = numpy.zeros((nElements,nSubQuadraturePoints),'d')
    jacobianInvArray = numpy.zeros((nElements,nSubQuadraturePoints,nSpace,nSpace),'d')

    cfemIntegrals.parametricMaps_getJacobianValues(grad_psi,
                                                   elementNodesArray,
                                                   nodeArray,
                                                   jacobianArray,
                                                   jacobianDetArray,
                                                   jacobianInvArray)


    jacobianDetArrayAbs = numpy.absolute(jacobianDetArray)
    #weights and points shaped like nSubElements x nQuadraturePointsSubElement
    q_sub_dV = numpy.zeros((nElements,nSubQuadraturePoints),'d')
    q_sub_x  = numpy.zeros((nElements,nSubQuadraturePoints,3),'d')

    cfemIntegrals.calculateIntegrationWeights(jacobianDetArrayAbs,
                                              weights_ref,
                                              q_sub_dV)

    cfemIntegrals.parametricMaps_getValues(psi,
                                           elementNodesArray,
                                           nodeArray,
                                           q_sub_x)


    #clean up
    del tri0
    del tri1

    #exit
    return q_sub_dV,q_sub_x
예제 #11
0
    def readFromPolyFile(self, filebase, flagsAdd="", verbose=0):
        """Reads in the triangle representation from filebase.poly file.

        Parameters
        ----------
        filebase : str
            The filename with the triangluation.
        flagsAdd : str
        verbose : int
            A flag indicating how much information to pipe to stdout.

        Notes
        -----
        Function assumes the nbase data member is set appropriately.
        """
        reader = TriangleUtils.TriangleInputFileReader()
        if verbose > 0:
            print 'readFromPolyFile filebase= ', filebase
        #end if

        polyDataInfo, polyData = reader.readPoly(filebase,
                                                 nbase=self.nbase,
                                                 verbose=verbose)

        if verbose > 3:
            for type in ['node', 'segment', 'hole', 'region']:
                print 'Poly: ', type, 'Info= \n', polyDataInfo[type], '\n'
            #end for
        #end if

        nodes, nodesA, nodesM = (polyData['node']['nodes'],
                                 polyData['node']['nodeAttributes'],
                                 polyData['node']['nodeMarkers'])
        segments, segmentsM = (polyData['segment']['segments'],
                               polyData['segment']['segmentMarkers'])
        holes = polyData['hole']['holes']
        regions = polyData['region']['regions']

        if verbose > 3:
            print """Poly file read:
            nodes   = \n%s\n nodeAttributes= \n%s\n nodeMarkers= \n%s\n
            segments= \n%s\n segmentMarkers= \n%s\n
            holes   = \n%s\n
            regions = \n%s\n
            """ % (nodes, nodesA, nodesM, segments, segmentsM, holes, regions)
        #end if
        tri0 = triangleWrappers.new()

        if nodesM == None:
            triangleWrappers.setPoints(tri0, nodes)
        else:
            nodesMtmp = numpy.zeros(nodesM.shape, 'i')
            nodesMtmp[:] = nodesM
            nodesM = nodesMtmp
            triangleWrappers.setPointsAndMarkers(tri0, nodes, nodesM)
        if not nodesA == None:
            triangleWrappers.setPointAttributes(tri0, nodesA)
        #end if
        if segmentsM == None:
            triangleWrappers.setSegments(tri0, segments)
        else:
            triangleWrappers.setSegmentsAndMarkers(tri0, segments, segmentsM)
        #end if
        if (not holes == None):
            triangleWrappers.setHoles(tri0, holes)
        #end if
        if (not regions == None):
            #print 'setting trin1 regions=\n',regions2
            triangleWrappers.setRegions(tri0, regions)
        #end if

        flags = flagsAdd + self.baseFlags
        if flags.find('p') == -1:
            print 'flags = ', flags, ' must have p, appending'
            flags += "p"
        #end
        if flags.find('v') >= 0:
            self.makeVoronoi = True
            if verbose > 0:
                print 'readNodeAndEle makeVoronoi= ', self.makeVoronoi, ' flags= ', flags
        #end if
        self.lastFlags = flags
        #reset data representations if necessary
        self.resetDefaultTrirep(index=0, verbose=verbose)
        if self.makeVoronoi:
            self.resetDefaultVorrep(index=0, verbose=verbose)
        #end vorrep initialized

        if self.makeVoronoi:
            triangleWrappers.applyTriangulate(flags, tri0, self.trirep[0],
                                              self.vorrep[0])
            #handles no longer contain trivial representations
            self.trirepDefaultInit[0] = False
            self.vorrepDefaultInit[0] = False
        else:
            triangleWrappers.applyTriangulateNoVoronoi(flags, tri0,
                                                       self.trirep[0])
            #handle no longer contains trivial representations
            self.trirepDefaultInit[0] = False
        #end if

        #clean up?
        del tri0