コード例 #1
0
ファイル: imagery.py プロジェクト: GCTMODS/OverlayEditor
    def getplacement(self,x,y,level,fetch):
        (name,url)=self.provider_url(x,y,level)
        if name in self.placementcache:
            # Already created
            placement=self.placementcache[name]
        elif fetch:
            # Make a new one. We could also do this if the image file is available, but don't since layout is expensive.
            (north,west)=self.xy2latlon(x,y,level)
            (south,east)=self.xy2latlon(x+1,y+1,level)
            placement=DrapedImage(name, 65535, [[Node([west,north,0,1]),Node([east,north,1,1]),Node([east,south,1,0]),Node([west,south,0,0])]])
            placement.load(self.canvas.lookup, self.canvas.defs, self.canvas.vertexcache)
            self.placementcache[name]=placement
            # Initiate fetch of image and do layout. Prioritise more detail.
            self.q.put((self.initplacement, (placement,name,url)))
        else:
            placement=None

        # Load it if it's not loaded but is ready to be
        if placement and not placement.islaidout() and Polygon.islaidout(placement):
            try:
                if __debug__: clock=time.clock()
                filename=self.filecache.get(name)	# downloaded image or None
                self.canvas.vertexcache.allocate_dynamic(placement, True)	# couldn't do this in thread context
                placement.definition.texture=self.canvas.vertexcache.texcache.get(filename, wrap=False, downsample=False, fixsize=True)
                if __debug__: print "%6.3f time in imagery load   for %s" % (time.clock()-clock, placement.name)
                assert placement.islaidout()
            except:
                if __debug__: print_exc()
                # Some failure - perhaps corrupted image?
                placement.clearlayout()
                placement=None
                self.placementcache[name]=None

        return placement
コード例 #2
0
ファイル: imagery.py プロジェクト: rromanchuk/OverlayEditor
    def initplacement(self, tls, x, y, level):

        key = (x, y, level)
        if key in self.placementcache:
            return  # was created while this task was queued

        (name, url, minsize) = self.provider_url(*key)
        filename = self.filecache.fetch(self.session, name, url, minsize)
        if not filename:
            # Couldn't fetch image
            if filename is False:  # Definitively unavailable
                self.placementcache[key] = False
            self.canvas.Refresh()  # Probably wanting to know this
            return

        try:
            if __debug__: clock = time.clock()
            texdata = self.canvas.vertexcache.texcache.get(filename,
                                                           alpha=False,
                                                           wrap=False,
                                                           downsample=False,
                                                           fixsize=True,
                                                           defer=True)
        except:
            if __debug__: print_exc()
            self.placementcache[key] = False  # Couldn't load image
            self.canvas.Refresh()  # Probably wanting to know this
            return

        # Make a new placement
        (north, west) = self.xy2latlon(x, y, level)
        (south, east) = self.xy2latlon(x + 1, y + 1, level)
        placement = DrapedImage(name, 65535, [[
            Node([west, north, 0, 1]),
            Node([east, north, 1, 1]),
            Node([east, south, 1, 0]),
            Node([west, south, 0, 0])
        ]])
        placement.load(self.canvas.lookup, self.canvas.defs,
                       self.canvas.vertexcache)
        if isinstance(texdata, tuple):
            placement.texdata = texdata
        else:
            placement.definition.texture = texdata  # already in the cache
        if __debug__: clock = time.clock()
        placement.layout(self.tile, tls=tls)
        if not placement.dynamic_data.size:
            if __debug__:
                print "DrapedImage layout failed for %s - no tris" % placement.name
            placement = False
        else:
            if __debug__:
                print "%6.3f time in imagery read & layout for %s" % (
                    time.clock() - clock, placement.name)
            self.canvas.Refresh(
            )  # Probably wanting to display this - will be allocated during OnPaint
        self.placementcache[key] = placement
        return
コード例 #3
0
    def getplacement(self, x, y, level, fetch):
        (name, url) = self.provider_url(x, y, level)
        if name in self.placementcache:
            # Already created
            placement = self.placementcache[name]
        elif fetch:
            # Make a new one. We could also do this if the image file is available, but don't since layout is expensive.
            (north, west) = self.xy2latlon(x, y, level)
            (south, east) = self.xy2latlon(x + 1, y + 1, level)
            placement = DrapedImage(name, 65535, [[
                Node([west, north, 0, 1]),
                Node([east, north, 1, 1]),
                Node([east, south, 1, 0]),
                Node([west, south, 0, 0])
            ]])
            placement.load(self.canvas.lookup, self.canvas.defs,
                           self.canvas.vertexcache)
            self.placementcache[name] = placement
            # Initiate fetch of image and do layout. Prioritise more detail.
            self.q.put((self.initplacement, (placement, name, url)))
        else:
            placement = None

        # Load it if it's not loaded but is ready to be
        if placement and not placement.islaidout() and Polygon.islaidout(
                placement):
            try:
                if __debug__: clock = time.clock()
                filename = self.filecache.get(name)  # downloaded image or None
                self.canvas.vertexcache.allocate_dynamic(
                    placement, True)  # couldn't do this in thread context
                placement.definition.texture = self.canvas.vertexcache.texcache.get(
                    filename, wrap=False, downsample=False, fixsize=True)
                if __debug__:
                    print "%6.3f time in imagery load   for %s" % (
                        time.clock() - clock, placement.name)
                assert placement.islaidout()
            except:
                if __debug__: print_exc()
                # Some failure - perhaps corrupted image?
                placement.clearlayout()
                placement = None
                self.placementcache[name] = None

        return placement
コード例 #4
0
ファイル: imagery.py プロジェクト: Marginal/OverlayEditor
    def initplacement(self, tls, x, y, level):

        key = (x, y, level)
        if key in self.placementcache:
            return	# was created while this task was queued

        (name, url, minsize) = self.provider_url(*key)
        filename = self.filecache.fetch(self.session, name, url, minsize)
        if not filename:
            # Couldn't fetch image
            if filename is False:		# Definitively unavailable
                self.placementcache[key] = False
            self.canvas.Refresh()		# Probably wanting to know this
            return

        try:
            if __debug__: clock=time.clock()
            texdata = self.canvas.vertexcache.texcache.get(filename, alpha=False, wrap=False, downsample=False, fixsize=True, defer=True)
        except:
            if __debug__: print_exc()
            self.placementcache[key] = False	# Couldn't load image
            self.canvas.Refresh()		# Probably wanting to know this
            return

        # Make a new placement
        (north,west) = self.xy2latlon(x, y, level)
        (south,east) = self.xy2latlon(x+1, y+1, level)
        placement = DrapedImage(name, 65535, [[Node([west, north, 0, 1]),
                                               Node([east, north, 1, 1]),
                                               Node([east, south, 1, 0]),
                                               Node([west, south, 0, 0])]])
        placement.load(self.canvas.lookup, self.canvas.defs, self.canvas.vertexcache)
        if isinstance(texdata, tuple):
            placement.texdata = texdata
        else:
            placement.definition.texture = texdata	# already in the cache
        if __debug__: clock=time.clock()
        placement.layout(self.tile, tls=tls)
        if not placement.dynamic_data.size:
            if __debug__: print "DrapedImage layout failed for %s - no tris" % placement.name
            placement = False
        else:
            if __debug__: print "%6.3f time in imagery read & layout for %s" % (time.clock()-clock, placement.name)
            self.canvas.Refresh()	# Probably wanting to display this - will be allocated during OnPaint
        self.placementcache[key] = placement
        return