Changeset 2261


Ignore:
Timestamp:
Jan 20, 2006, 10:59:35 AM (18 years ago)
Author:
duncan
Message:

added geo-ref to poly to region method

Location:
inundation
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • inundation/coordinate_transforms/geo_reference.py

    r2256 r2261  
    114114                              points_geo_ref=None):
    115115        """
    116         Change the reference of a list or Numeric array of points.
     116        Change the geo reference of a list or Numeric array of points to
     117        be this reference.(The reference used for this object)
    117118        If the points do not have a geo ref, assume 'absolute' values
    118119        """
     120        # currently untested
     121        if points_geo_ref is self:
     122            return points
     123       
    119124        is_list = False
    120125        if type(points) == types.ListType:
     
    140145        if is_list:
    141146            points = points.tolist()
    142         # return points
     147        return points
     148   
     149    def get_absolute(self, points):
     150        """
     151        Given a set of points geo referenced to this instance,
     152        return the points as absolute values.
     153        """
     154       
     155        is_list = False
     156        if type(points) == types.ListType:
     157            is_list = True
     158            if len(points)>0 and type(points[0]) \
     159                   not in [types.ListType,types.TupleType]:
     160                #a single point is being passed.  make it a list of lists
     161                points = [points]
     162        elif type(points) == ArrayType:
     163            if len(points.shape) == 1:
     164                points = [points]       
     165           
     166        # convert into array
     167        points = array(points).astype(Float)
     168     
     169        # add primary geo ref from points
     170        points[:,0] += self.xllcorner
     171        points[:,1] += self.yllcorner
     172        if is_list:
     173            points = points.tolist()
     174           
    143175        return points
    144176
  • inundation/coordinate_transforms/test_geo_reference.py

    r2253 r2261  
    9494           
    9595    def test_change_points_geo_ref(self):
    96         x = 3.0
    97         y = 3.0
    98         g = Geo_reference(56,x,y)
    99         lofl = [[3.0,3.0], [6.0,6.0]]
     96        x = 433.0
     97        y = 3.0
     98        g = Geo_reference(56,x,y)
     99        lofl = [[3.0,311.0], [677.0,6.0]]
    100100        new_lofl = g.change_points_geo_ref(lofl)
    101101        #print "lofl",lofl
     
    110110    def test_change_points_geo_ref2(self):
    111111        x = 3.0
    112         y = 3.0
    113         g = Geo_reference(56,x,y)
    114         lofl = [[3.0,3.0]]
     112        y = 543.0
     113        g = Geo_reference(56,x,y)
     114        lofl = [[3.0,388.0]]
    115115        new_lofl = g.change_points_geo_ref(lofl)
    116116        #print "lofl",lofl
     
    125125    def test_change_points_geo_ref3(self):
    126126        x = 3.0
    127         y = 3.0
    128         g = Geo_reference(56,x,y)
    129         lofl = [3.0,3.0]
     127        y = 443.0
     128        g = Geo_reference(56,x,y)
     129        lofl = [3.0,345.0]
    130130        new_lofl = g.change_points_geo_ref(lofl)
    131131        #print "lofl",lofl
     
    141141    def test_change_points_geo_ref4(self):
    142142        x = 3.0
    143         y = 3.0
    144         g = Geo_reference(56,x,y)
    145         lofl = array([[3.0,3.0], [6.0,6.0]])
     143        y = 443.0
     144        g = Geo_reference(56,x,y)
     145        lofl = array([[3.0,323.0], [6.0,645.0]])
    146146        new_lofl = g.change_points_geo_ref(lofl)
    147147        #print "4 lofl",lofl
     
    155155       
    156156    def test_change_points_geo_ref5(self):
    157         x = 3.0
    158         y = 3.0
    159         g = Geo_reference(56,x,y)
    160         lofl = array([[3.0,3.0]])
     157        x = 103.0
     158        y = 3.0
     159        g = Geo_reference(56,x,y)
     160        lofl = array([[3.0,323.0]])
    161161        new_lofl = g.change_points_geo_ref(lofl)
    162162        #print "5 lofl",lofl
     
    170170       
    171171    def test_change_points_geo_ref6(self):
    172         x = 3.0
    173         y = 3.0
    174         g = Geo_reference(56,x,y)
    175         lofl = array([3.0,3.0])
     172        x = 53.0
     173        y = 3.0
     174        g = Geo_reference(56,x,y)
     175        lofl = array([355.0,3.0])
    176176        new_lofl = g.change_points_geo_ref(lofl)
    177177        #print "lofl",lofl
     
    185185     
    186186    def test_change_points_geo_ref7(self):
    187         x = 3.0
     187        x = 23.0
    188188        y = 3.0
    189189        point_x = 9.0
     
    191191        g = Geo_reference(56,x,y)
    192192        points_geo_ref = Geo_reference(56,point_x,point_y)
    193         lofl = [[3.0,3.0], [6.0,6.0]]
     193        lofl = [[3.0,30.0], [67.0,6.0]]
    194194        new_lofl = g.change_points_geo_ref(lofl,points_geo_ref=points_geo_ref)
    195195        #print "lofl",lofl
     
    201201            self.failUnless(point[0]+point_x-x==new_point[0], ' failed')
    202202            self.failUnless(point[1]+point_y-y==new_point[1], ' failed')
    203                
     203     
     204    def test_get_absolute(self):
     205        x = 7.0
     206        y = 3.0
     207       
     208        g = Geo_reference(56,x,y)
     209        lofl = [[3.0,34.0], [64.0,6.0]]
     210        new_lofl = g.get_absolute(lofl)
     211        #print "lofl",lofl
     212        #print "new_lofl",new_lofl
     213
     214        self.failUnless(type(new_lofl) == types.ListType, ' failed')
     215        self.failUnless(type(new_lofl) == type(lofl), ' failed')
     216        for point,new_point in map(None,lofl,new_lofl):
     217            self.failUnless(point[0]+x==new_point[0], ' failed')
     218            self.failUnless(point[1]+y==new_point[1], ' failed')
     219                       
    204220    def test___cmp__(self):
    205221        g = Geo_reference(56,1.9,1.9,)
  • inundation/pmesh/mesh.py

    r2243 r2261  
    358358        return self.vertices
    359359   
     360    def get_vertices(self):
     361        """
     362        Return a list of the vertices.  The x and y values will be absolute
     363        Easting and Northings for the zone of the current geo_ref.
     364        """
     365        return self.vertices
     366   
    360367    def calcArea(self):
    361368        ax = self.vertices[0].x
     
    571578       
    572579        return (dic.__cmp__(dic_other))
    573        
    574     def generateMesh(self, mode = None, maxArea = None, isRegionalMaxAreas = True):
     580   
     581    def addUserPoint(self, pointType, x,y):
     582        if pointType == Vertex:
     583            point = self.addUserVertex(x,y)
     584        if pointType == Hole:
     585            point = self._addHole(x,y)
     586        if pointType == Region:
     587            point = self._addRegion(x,y)
     588        return point
     589   
     590    def addUserVertex(self, x,y):
     591        v=Vertex(x, y)
     592        self.userVertices.append(v)
     593        return v
     594
     595    def _addHole(self, x,y):
     596        h=Hole(x, y)
     597        self.holes.append(h)
     598        return h
     599   
     600    def _addRegion(self, x,y):
     601        h=Region(x, y)
     602        self.regions.append(h)
     603        return h
     604   
     605    def add_region(self, x,y, geo_reference=None):
     606        [x,y] = self.geo_reference.change_points_geo_ref([x,y],
     607                                                 points_geo_ref=geo_reference)
     608        return self._addRegion(x, y)
     609
     610    # Depreciated
     611    def addRegionEN(self, x,y):
     612        print "depreciated, use add_region"
     613        return self.add_region(x,y)
     614   
     615    def add_region_from_polygon(self, polygon, tags=None,
     616                             max_area=None, geo_reference=None):
     617        """
     618        Add a polygon with tags to the current mesh, as a region.
     619        The maxArea of the region can be specified.
     620
     621        If a geo_ref is given, this is used.
     622        If not;
     623        The x,y info is assumed to be Easting and Northing, absolute,
     624        for the meshes zone.
     625
     626        polygon a list of points, in meters that describe the polygon
     627             (e.g. [[x1,y1],[x2,y2],...]
     628        tags (e.g.{'wall':[0,1,3],'ocean':[2]})
     629
     630        This returns the region instance, so if the user whats to modify
     631        it they can.
     632       
     633        """
     634        #FIXME: take into account georef on mesh side
     635        polygon = self.geo_reference.change_points_geo_ref(polygon,
     636                                                 points_geo_ref=geo_reference)
     637        #print "polygon - should be relative to mesh geo_ref",polygon
     638        #create points, segs and tags
     639        region_dict = {}
     640        region_dict['points'] = polygon
     641       
     642        #Create segments
     643        #E.g. [[0,1], [1,2], [2,3], [3,0]]
     644        #from polygon
     645        #[0,1,2,3]
     646        segments = []
     647        N = len(polygon)
     648        for i in range(N):
     649            lo = i
     650            hi = (lo + 1) % N
     651            segments.append( [lo, hi] )
     652        region_dict['segments'] = segments
     653
     654
     655        #Create tags
     656        #E.g. ['wall', 'wall', 'ocean', 'wall']
     657        # from a dic
     658        #{'wall':[0,1,3],'ocean':[2]}
     659        segment_tags = ['']*N
     660        if tags is not None:
     661            for key in tags:
     662                indices = tags[key]
     663                for i in indices:
     664                    segment_tags[i] = key
     665        region_dict['segment_tags'] = segment_tags
     666   
     667        self.addVertsSegs(region_dict) #this is assuming absolute geos
     668   
     669        #get inner point
     670        inner_point = point_in_polygon(polygon)
     671        inner = self.add_region(inner_point[0], inner_point[1],
     672                               geo_reference=self.geo_reference)
     673
     674        if max_area is not None:
     675            inner.setMaxArea(max_area)
     676        return inner
     677       
     678    def getUserVertices(self):
     679        return self.userVertices
     680   
     681    def getUserSegments(self):
     682        allSegments = self.userSegments + self.alphaUserSegments
     683        #print "self.userSegments",self.userSegments
     684        #print "self.alphaUserSegments",self.alphaUserSegments
     685        #print "allSegments",allSegments
     686        return allSegments
     687   
     688    def deleteUserSegments(self,seg):
     689        if self.userSegments.count(seg) == 0:
     690            self.alphaUserSegments.remove(seg)
     691            pass
     692        else:
     693            self.userSegments.remove(seg)
     694           
     695    def clearUserSegments(self):
     696        self.userSegments = []
     697        self.alphaUserSegments = []
     698               
     699    def getTriangulation(self):
     700        return self.meshTriangles
     701   
     702    def getMeshVertices(self):
     703        return self.meshVertices
     704 
     705    def getMeshSegments(self):
     706        return self.meshSegments
     707   
     708    def getHoles(self):
     709        return self.holes
     710   
     711    def getRegions(self):
     712        return self.regions
     713   
     714    def isTriangulation(self):
     715        if self.meshVertices == []:
     716            return False
     717        else:
     718            return True
     719   
     720    def addUserSegment(self, v1,v2):
     721        """
     722        PRECON: A segment between the two vertices is not already present.
     723        Check by calling isUserSegmentNew before calling this function.
     724       
     725        """
     726        s=Segment( v1,v2)
     727        self.userSegments.append(s)
     728        return s
     729       
     730    def generateMesh(self, mode = None, maxArea = None,
     731                     isRegionalMaxAreas = True):
    575732        """
    576733        Based on the current user vaules, holes and regions
     
    592749            # it's more comlex than this.  eg holes
    593750        if not re.match('z',self.mode):
    594             self.mode += 'z' # z - Number all items starting from zero (rather than one)
     751            self.mode += 'z' # z - Number all items starting from zero
     752                             # (rather than one)
    595753        if not re.match('n',self.mode):
    596754            self.mode += 'n' # n - output a list of neighboring triangles
     
    631789        #print "generated",generatedMesh
    632790        generatedMesh['generatedsegmentmarkerlist'] = \
    633                      segment_ints2strings(generatedMesh['generatedsegmentmarkerlist'],
     791             segment_ints2strings(generatedMesh['generatedsegmentmarkerlist'],
    634792                                  segconverter)
    635793        #print "processed gen",generatedMesh['generatedsegmentmarkerlist']
     
    641799        if len(generatedMesh['generatedpointattributelist'][0])==0:
    642800            self.attributeTitles = []
    643         generatedMesh['generatedpointattributetitlelist']=self.attributeTitles     
     801        generatedMesh['generatedpointattributetitlelist']= \
     802                                            self.attributeTitles
    644803
    645804        self.setTriangulation(generatedMesh)
    646    
    647     def addUserPoint(self, pointType, x,y):
    648         if pointType == Vertex:
    649             point = self.addUserVertex(x,y)
    650         if pointType == Hole:
    651             point = self.addHole(x,y)
    652         if pointType == Region:
    653             point = self.addRegion(x,y)
    654         return point
    655    
    656     def addUserVertex(self, x,y):
    657         v=Vertex(x, y)
    658         self.userVertices.append(v)
    659         return v
    660 
    661     def addHole(self, x,y):
    662         h=Hole(x, y)
    663         self.holes.append(h)
    664         return h
    665    
    666     def addRegion(self, x,y):
    667         h=Region(x, y)
    668         self.regions.append(h)
    669         return h
    670 
    671     #FIXME(DSG-DSG) remove EN, have a relative flag.
    672     def addRegionEN(self, x,y):
    673         h=Region(x-self.geo_reference.xllcorner,
    674                  y-self.geo_reference.yllcorner)
    675         self.regions.append(h)
    676         return h
    677     def addRegionFromPolygon(self, polygon, tags=None,
    678                              maxArea=None, Geo_ref=None):
    679         #take into account georef
    680         #create points, segs and tags
    681         region_dict = {}
    682         region_dict['points'] = polygon
    683 
    684         #Create segments
    685         #E.g. [[0,1], [1,2], [2,3], [3,0]]
    686         segments = []
    687         N = len(polygon)
    688         for i in range(N):
    689             lo = i
    690             hi = (lo + 1) % N
    691             segments.append( [lo, hi] )
    692         region_dict['segments'] = segments
    693 
    694 
    695         #Create tags
    696         #E.g. ['wall', 'wall', 'ocean', 'wall']
    697 
    698         segment_tags = ['']*N
    699         if tags is not None:
    700             for key in tags:
    701                 indices = tags[key]
    702                 for i in indices:
    703                     segment_tags[i] = key
    704         region_dict['segment_tags'] = segment_tags
    705    
    706         self.addVertsSegs(region_dict) #this is assuming absolute geos
    707    
    708         #get inner point
    709         inner_point = point_in_polygon(polygon)
    710         inner = self.addRegionEN(inner_point[0], inner_point[1])
    711 
    712         if maxArea is not None:
    713             inner.setMaxArea(maxArea)
    714        
    715     def getUserVertices(self):
    716         return self.userVertices
    717    
    718     def getUserSegments(self):
    719         allSegments = self.userSegments + self.alphaUserSegments
    720         #print "self.userSegments",self.userSegments
    721         #print "self.alphaUserSegments",self.alphaUserSegments
    722         #print "allSegments",allSegments
    723         return allSegments
    724    
    725     def deleteUserSegments(self,seg):
    726         if self.userSegments.count(seg) == 0:
    727             self.alphaUserSegments.remove(seg)
    728             pass
    729         else:
    730             self.userSegments.remove(seg)
    731            
    732     def clearUserSegments(self):
    733         self.userSegments = []
    734         self.alphaUserSegments = []
    735                
    736     def getTriangulation(self):
    737         return self.meshTriangles
    738    
    739     def getMeshVertices(self):
    740         return self.meshVertices
    741  
    742     def getMeshSegments(self):
    743         return self.meshSegments
    744    
    745     def getHoles(self):
    746         return self.holes
    747    
    748     def getRegions(self):
    749         return self.regions
    750    
    751     def isTriangulation(self):
    752         if self.meshVertices == []:
    753             return False
    754         else:
    755             return True
    756    
    757     def addUserSegment(self, v1,v2):
    758         """
    759         PRECON: A segment between the two vertices is not already present.
    760         Check by calling isUserSegmentNew before calling this function.
    761        
    762         """
    763         s=Segment( v1,v2)
    764         self.userSegments.append(s)
    765         return s
    766805   
    767806    def clearTriangulation(self):
     
    777816        """
    778817        assert self.getUserSegments() == []
    779         self.userVertices, counter =  self.removeDuplicatedVertices(self.userVertices)
     818        self.userVertices, counter =  self.removeDuplicatedVertices(
     819            self.userVertices)
    780820        return counter
    781821   
     
    852892           
    853893    def isUserSegmentNew(self, v1,v2):
    854         identicalSegs= [x for x in self.getUserSegments() if (x.vertices[0] == v1 and x.vertices[1] == v2) or (x.vertices[0] == v2 and x.vertices[1] == v1) ]
     894        identicalSegs= [x for x in self.getUserSegments() \
     895                        if (x.vertices[0] == v1 and x.vertices[1] == v2)
     896        or (x.vertices[0] == v2 and x.vertices[1] == v1) ]
    855897       
    856898        return len(identicalSegs) == 0
     
    897939                        regions=None):
    898940        """
    899         Convert the Mesh to a dictionary of the lists needed for the triang modul;
     941        Convert the Mesh to a dictionary of the lists needed for the
     942        triang module
    900943        points list: [(x1,y1),(x2,y2),...] (Tuples of doubles)
    901944        pointattributelist: [(a11,a12,...),(a21,a22),...] (Tuples of doubles)
    902945        segment list: [(point1,point2),(p3,p4),...] (Tuples of integers)
    903         hole list: [(x1,y1),...](Tuples of doubles, one inside each hole region)
     946        hole list: [(x1,y1),...](Tuples of doubles, one inside each hole)
    904947        regionlist: [ (x1,y1,tag, max area),...] (Tuple of 3-4 doubles)
    905948       
     
    9601003    def Mesh2MeshList(self):
    9611004        """
    962         Convert the Mesh to a dictionary of lists describing the triangulation variables;
     1005        Convert the Mesh to a dictionary of lists describing the
     1006        triangulation variables;
    9631007        generated point list: [(x1,y1),(x2,y2),...] (Tuples of doubles)
    964         generated point attribute list: [(a11,a12,...),(a21,a22),...] (Tuples of doubles)
    965         generated point attribute title list:[A1Title, A2Title ...] (list of strings)
    966         generated segment list: [(point1,point2),(p3,p4),...] (Tuples of integers)
     1008        generated point attribute list: [(a11,a12,...),(a21,a22),...]
     1009            (Tuples of doubles)
     1010        generated point attribute title list:[A1Title, A2Title ...]
     1011            (list of strings)
     1012        generated segment list: [(point1,point2),(p3,p4),...]
     1013            (Tuples of integers)
    9671014        generated segment tag list: [tag,tag,...] list of strings
    9681015
     
    9711018        generated triangle attribute list: [s1,s2,...] list of strings
    9721019
    973         generated triangle neighbor list: [(t1,t2,t3), (t4,t5,t6),....] tuple of triangles
     1020        generated triangle neighbor list: [(t1,t2,t3), (t4,t5,t6),....]
     1021            tuple of triangles
    9741022       
    9751023        Used to produce .tsh file
     
    10101058        triangleneighborlist = []
    10111059        for tri in self.meshTriangles: 
    1012             trianglelist.append((tri.vertices[0].index,tri.vertices[1].index,tri.vertices[2].index)) 
     1060            trianglelist.append((tri.vertices[0].index,tri.vertices[1].index,
     1061                                 tri.vertices[2].index)) 
    10131062            triangleattributelist.append([tri.attribute])
    10141063            neighborlist = [-1,-1,-1]
     
    10461095        returned from the triang module       
    10471096        generated point list: [(x1,y1),(x2,y2),...] (Tuples of doubles) 
    1048         generated point attribute list:[(P1att1,P1attt2, ...),(P2att1,P2attt2,...),...]
    1049         generated point attribute title list:[A1Title, A2Title ...] (list of strings)
    1050         generated segment list: [(point1,point2),(p3,p4),...] (Tuples of integers)
     1097        generated point attribute list:[(P1att1,P1attt2, ...),
     1098            (P2att1,P2attt2,...),...]
     1099        generated point attribute title list:[A1Title, A2Title ...]
     1100            (list of strings)
     1101        generated segment list: [(point1,point2),(p3,p4),...]
     1102            (Tuples of integers)
    10511103        generated segment marker list: [S1Tag, S2Tag, ...] (list of ints)
    1052         triangle list:  [(point1,point2, point3),(p5,p4, p1),...] (Tuples of integers)
    1053         triangle neighbor list: [(triangle1,triangle2, triangle3),(t5,t4, t1),...] (Tuples of integers) -1 means there's no triangle neighbor
    1054         triangle attribute list: [(T1att), (T2att), ...] (list of a list of strings)
     1104        triangle list:  [(point1,point2, point3),(p5,p4, p1),...]
     1105            (Tuples of integers)
     1106        triangle neighbor list: [(triangle1,triangle2, triangle3),
     1107            (t5,t4, t1),...] (Tuples of integers)
     1108            -1 means there's no triangle neighbor
     1109        triangle attribute list: [(T1att), (T2att), ...]
     1110            (list of a list of strings)
    10551111        """
    10561112        #Clear the current generated mesh values
     
    10741130
    10751131        index = 0
    1076         for seg,marker in map(None,genDict['generatedsegmentlist'],genDict['generatedsegmentmarkerlist']):
     1132        for seg,marker in map(None,genDict['generatedsegmentlist'],
     1133                              genDict['generatedsegmentmarkerlist']):
    10771134            segObject = Segment( self.meshVertices[seg[0]],
    10781135                           self.meshVertices[seg[1]], tag = marker )
     
    11151172                else:
    11161173                    ObjectNeighbor.append(None)
    1117             self.meshTriangles[index].setNeighbors(ObjectNeighbor[0],ObjectNeighbor[1],ObjectNeighbor[2])
     1174            self.meshTriangles[index].setNeighbors(ObjectNeighbor[0],
     1175                                                   ObjectNeighbor[1],
     1176                                                   ObjectNeighbor[2])
    11181177            index += 1
    11191178
     
    11501209
    11511210        #index = 0
    1152         for seg,tag in map(None,genDict['segmentlist'],genDict['segmenttaglist']):
     1211        for seg,tag in map(None,genDict['segmentlist'],
     1212                           genDict['segmenttaglist']):
    11531213            segObject = Segment( self.userVertices[seg[0]],
    11541214                           self.userVertices[seg[1]], tag = tag )
     
    14251485   
    14261486    def representedAlphaUserSegment(self, v1,v2):
    1427         identicalSegs= [x for x in self.alphaUserSegments if (x.vertices[0] == v1 and x.vertices[1] == v2) or (x.vertices[0] == v2 and x.vertices[1] == v1) ]
     1487        identicalSegs= [x for x in self.alphaUserSegments \
     1488                        if (x.vertices[0] == v1 and x.vertices[1] == v2)
     1489        or (x.vertices[0] == v2 and x.vertices[1] == v1) ]
    14281490
    14291491        if identicalSegs == []:
     
    14341496   
    14351497    def representedUserSegment(self, v1,v2):
    1436         identicalSegs= [x for x in self.userSegments if (x.vertices[0] == v1 and x.vertices[1] == v2) or (x.vertices[0] == v2 and x.vertices[1] == v1) ]
     1498        identicalSegs= [x for x in self.userSegments \
     1499                        if (x.vertices[0] == v1 and x.vertices[1] == v2)
     1500        or (x.vertices[0] == v2 and x.vertices[1] == v1) ]
    14371501
    14381502        if identicalSegs == []:
     
    15151579    def boxsizeVerts(self):
    15161580        """
    1517         Returns a list of verts denoting a box or triangle that contains verts on the xmin, ymin, xmax and ymax axis.
     1581        Returns a list of verts denoting a box or triangle that contains
     1582        verts on the xmin, ymin, xmax and ymax axis.
    15181583        Structure: list of verts
    15191584        """
     
    15491614                ymax = vertex.y
    15501615                ymaxVert = vertex
    1551         verts, count = self.removeDuplicatedVertices([xminVert,xmaxVert,yminVert,ymaxVert])
     1616        verts, count = self.removeDuplicatedVertices([xminVert,
     1617                                                      xmaxVert,
     1618                                                      yminVert,
     1619                                                      ymaxVert])
    15521620         
    15531621        return verts
     
    15551623    def boxsize(self):
    15561624        """
    1557         Returns a list denoting a box that contains the entire structure of vertices
     1625        Returns a list denoting a box that contains the entire
     1626        structure of vertices
    15581627        Structure: [xmin, ymin, xmax, ymax]
    15591628        """
     
    15891658    def maxMinVertAtt(self, iatt):
    15901659        """
    1591         Returns a list denoting a box that contains the entire structure of vertices
     1660        Returns a list denoting a box that contains the entire structure
     1661        of vertices
    15921662        Structure: [xmin, ymin, xmax, ymax]
    15931663        """
     
    17981868        triangle_neighbors = []
    17991869        for tri in self.meshTriangles: 
    1800             triangles.append([tri.vertices[0].index,tri.vertices[1].index,tri.vertices[2].index]) 
     1870            triangles.append([tri.vertices[0].index,
     1871                              tri.vertices[1].index,
     1872                              tri.vertices[2].index]) 
    18011873            triangle_tags.append(tri.attribute)
    18021874            neighborlist = [-1,-1,-1]
     
    19522024                else:
    19532025                    ObjectNeighbor.append(None)
    1954             self.meshTriangles[index].setNeighbors(ObjectNeighbor[0],ObjectNeighbor[1],ObjectNeighbor[2])
     2026            self.meshTriangles[index].setNeighbors(ObjectNeighbor[0],
     2027                                                   ObjectNeighbor[1],
     2028                                                   ObjectNeighbor[2])
    19552029            index += 1
    19562030
     
    19802054
    19812055        #index = 0
    1982         for seg,tag in map(None,genDict['outline_segments'],genDict['outline_segment_tags']):
     2056        for seg,tag in map(None,genDict['outline_segments'],
     2057                           genDict['outline_segment_tags']):
    19832058            segObject = Segment( self.userVertices[seg[0]],
    19842059                           self.userVertices[seg[1]], tag = tag )
     
    35043579# Create a clear interface. eg
    35053580# have the interface methods more at the top of this file and add comments
     3581# for the interface functions/methods, use function_name (not functionName),
     3582
     3583#Currently
     3584#function_name methods assume absolute values.  Geo-refs can be passed in.
     3585#
     3586
     3587# instead of functionName
    35063588if __name__ == "__main__":
    35073589    #from mesh import *
  • inundation/pmesh/test_mesh.py

    r2200 r2261  
    16551655#___________end of Peters tests
    16561656
    1657     def test_addRegionFromPolygon(self):
     1657    def test_add_region_from_polygon(self):
    16581658        m=Mesh()
    1659         m.addRegionFromPolygon([[0,0],[1,0],[0,1]])
     1659        m.add_region_from_polygon([[0,0],[1,0],[0,1]])
    16601660        self.failUnless(len(m.regions)==1,
    16611661                        'FAILED!')
     
    16651665                        'FAILED!')
    16661666       
    1667     def test_addRegionFromPolygon2(self):
     1667    def test_add_region_from_polygon2(self):
    16681668        m=Mesh()
    1669         m.addRegionFromPolygon([[0,0],[1,0],[1,1],[0,1]],
     1669        m.add_region_from_polygon([[0,0],[1,0],[1,1],[0,1]],
    16701670                               {'tagin':[0,1],'bom':[2]})
    16711671        self.failUnless(len(m.regions)==1,
     
    16851685        self.failUnless(segs[3].tag=='',
    16861686                        'FAILED!')
    1687        
    1688        
    1689 
     1687       
     1688    def test_add_region_from_polygon3(self):
     1689        x=0
     1690        y=0
     1691        m=Mesh(geo_reference=Geo_reference(56,x,y))
     1692        polygon = [[0,0],[1,0],[1,1],[0,1]]
     1693        x_p = 1000
     1694        y_p = 4000
     1695        geo_ref_poly = Geo_reference(56, x_p, y_p)
     1696        polygon = geo_ref_poly.change_points_geo_ref(polygon)
     1697        #print "polygon", polygon
     1698        m.add_region_from_polygon(polygon,
     1699                               {'tagin':[0,1],'bom':[2]},
     1700                                  geo_reference=geo_ref_poly)
     1701        self.failUnless(len(m.regions)==1,
     1702                        'FAILED!')
     1703        segs = m.getUserSegments()
     1704        self.failUnless(len(segs)==4,
     1705                        'FAILED!')
     1706        self.failUnless(len(m.userVertices)==4,
     1707                        'FAILED!')
     1708        self.failUnless(segs[0].tag=='tagin',
     1709                        'FAILED!') 
     1710        self.failUnless(segs[1].tag=='tagin',
     1711                        'FAILED!')
     1712         
     1713        self.failUnless(segs[2].tag=='bom',
     1714                        'FAILED!')
     1715        self.failUnless(segs[3].tag=='',
     1716                        'FAILED!')
     1717        verts = m.getUserVertices()
     1718        #print "User verts",verts
     1719        #print 'polygon',polygon
     1720        #vert values are relative
     1721        for point,new_point in map(None,polygon,verts):
     1722            point_x = point[0] + geo_ref_poly.get_xllcorner()
     1723            new_point_x = new_point.x + m.geo_reference.get_xllcorner()
     1724            point_y = point[1] + geo_ref_poly.get_yllcorner()
     1725            new_point_y = new_point.y + m.geo_reference.get_yllcorner()
     1726            #print "point_y",point_y
     1727            #print "new_point_y",new_point_y
     1728           
     1729            self.failUnless(point_x == new_point_x, ' failed')
     1730            self.failUnless(point_y == new_point_y, ' failed')
     1731           
     1732         
     1733        #REJIG
     1734    def test_add_region_from_polygon4(self):
     1735        x=0
     1736        y=0
     1737        m=Mesh(geo_reference=Geo_reference(56,x,y))
     1738        polygon = [[0,0],[1,0],[1,1],[0,1]]
     1739       
     1740        m.add_region_from_polygon(polygon,
     1741                               {'tagin':[0,1],'bom':[2]})
     1742        self.failUnless(len(m.regions)==1,
     1743                        'FAILED!')
     1744        segs = m.getUserSegments()
     1745        self.failUnless(len(segs)==4,
     1746                        'FAILED!')
     1747        self.failUnless(len(m.userVertices)==4,
     1748                        'FAILED!')
     1749        self.failUnless(segs[0].tag=='tagin',
     1750                        'FAILED!') 
     1751        self.failUnless(segs[1].tag=='tagin',
     1752                        'FAILED!')
     1753         
     1754        self.failUnless(segs[2].tag=='bom',
     1755                        'FAILED!')
     1756        self.failUnless(segs[3].tag=='',
     1757                        'FAILED!')
     1758        verts = m.getUserVertices()
     1759        #print "User verts",verts
     1760        #print 'polygon',polygon
     1761        #vert values are relative
     1762        for point,new_point in map(None,polygon,verts):
     1763            point_x = point[0]
     1764            new_point_x = new_point.x + m.geo_reference.get_xllcorner()
     1765            #print "point_x",point_x
     1766            #print "new_point_x",new_point_x
     1767            point_y = point[1]
     1768            new_point_y = new_point.y + m.geo_reference.get_yllcorner()
     1769           
     1770            self.failUnless(point_x == new_point_x, ' failed')
     1771            self.failUnless(point_y == new_point_y, ' failed')
     1772
     1773
     1774       
    16901775def list_comp(A,B):
    16911776    yes = len(A)==len(B)
     
    16951780    return yes
    16961781
    1697 #___________end of Peters tests
    1698            
    16991782#-------------------------------------------------------------
    17001783if __name__ == "__main__":
Note: See TracChangeset for help on using the changeset viewer.