Method: clearImage
Clear tile
436847
function () {
        this.image = null;
        this.border = null;
        if (this.canvasContext)
            this.canvasContext.clearRect(0, 0, this.size.w, this.size.h);
    }
1323879
def clear_marking(self):
        """"""
        if self.marktag:
            try:
                self.canvas.delete_object_by_tag(self.marktag, redraw=False)
            except Exception:
                pass

        if self.markhltag:
            try:
                self.canvas.delete_object_by_tag(self.markhltag, redraw=False)
            except Exception:
                pass

        self.treeview.clear()  # Clear table too
        self.w.nshown.set_text('0')
        self.fitsimage.redraw()
147324
def clearOverlayTexture(self, ulOverlayHandle):
        """"""

        fn = self.function_table.clearOverlayTexture
        result = fn(ulOverlayHandle)
        return result
529255
private void clearArt(DeviceAnnouncement announcement) {
        final int player = announcement.getNumber();
        // Iterate over a copy to avoid concurrent modification issues
        for (DeckReference deck : new HashSet<DeckReference>(hotCache.keySet())) {
            if (deck.player == player) {
                hotCache.remove(deck);
                if (deck.hotCue == 0) {
                    deliverAlbumArtUpdate(player, null);  // Inform listeners that the artwork is gone.
                }
            }
        }
        // Again iterate over a copy to avoid concurrent modification issues
        for (DataReference art : new HashSet<DataReference>(artCache.keySet())) {
            if (art.player == player) {
                artCache.remove(art);
            }
        }
    }
310249
def clear(self):
        
        self._cx, self._cy = (0, 0)
        self._canvas.rectangle(self._device.bounding_box,
                               fill=self.default_bgcolor)
        self.flush()
835929
def erase(self):
        
        bounds = (self._cx, self._cy, self._cx + self._cw, self._cy + self._ch)
        self._canvas.rectangle(bounds, fill=self._bgcolor)
201734
def clear(self):
        """"""
        self.exposures = []
        self.exposure_labels = []
        self.exposure_combo_boxes = []
        self.exposure_edit_buttons = []
        self.mode = CHOOSE_MODE

        self.layer_purpose = None
        self.layer_mode = None
        self.special_case_index = None

        self.value_maps = {}
        self.thresholds = {}

        # Temporary attributes
        self.threshold_classes = OrderedDict()
        self.active_exposure = None

        self.list_unique_values = None
        self.tree_mapping_widget = None

        clear_layout(self.left_layout)
        clear_layout(self.right_layout)
1277838
def clean(image, mask=None, iterations = 1):
    '''
    '''
    global clean_table
    if mask is None:
        masked_image = image
    else:
        masked_image = image.astype(bool).copy()
        masked_image[~mask] = False
    result = table_lookup(masked_image, clean_table, False, iterations)
    if not mask is None:
        result[~mask] = image[~mask]
    return result
98725
function () {
		var i, tile;
		for (i in this._tiles) {
			if (this._tiles[i].coords.z !== this._tileZoom) {
				tile = this._tiles[i].el;

				tile.onload = L.Util.falseFn;
				tile.onerror = L.Util.falseFn;

				if (!tile.complete) {
					tile.src = L.Util.emptyImageUrl;
					L.DomUtil.remove(tile);
				}
			}
		}
	}
12630
def map_clear(
    m: tcod.map.Map, transparent: bool = False, walkable: bool = False
) -> None:
    
    m.transparent[:] = transparent
    m.walkable[:] = walkable
876315
def _clear(self, contours=True, components=True, anchors=True,
               guidelines=True, image=True):
        
        if contours:
            self.clearContours()
        if components:
            self.clearComponents()
        if anchors:
            self.clearAnchors()
        if guidelines:
            self.clearGuidelines()
        if image:
            self.clearImage()
813267
void clear() {
        offset = intLen = 0;
        for (int index=0, n=value.length; index < n; index++)
            value[index] = 0;
    }
51586
public void clear() {
        if (arrMask != null) {
            for (int y = 0; y < height; y++) {
                for (int x = 0; x < width; x++) {
                    arrMask[x][y] = false;
                }
            }
        }
    }
444954
def _flush_tile_queue(self, surface):
        
        tw, th = self.data.tile_size
        ltw = self._tile_view.left * tw
        tth = self._tile_view.top * th
        surface_blit = surface.blit

        self.data.prepare_tiles(self._tile_view)

        for x, y, l, image in self._tile_queue:
            surface_blit(image, (x * tw - ltw, y * th - tth))
769982
def clear(self):
        """"""
        self._imgobj = None
        try:
            # See if there is an image on the canvas
            self.canvas.delete_object_by_tag(self._canvas_img_tag)
            self.redraw()
        except KeyError:
            pass
1368691
public static void clear(Image img) {
        Graphics g = img.getGraphics();
        
        try {
            if (g instanceof Graphics2D) {
                ((Graphics2D) g).setComposite(AlphaComposite.Clear);
            } else {
                g.setColor(new Color(0, 0, 0, 0));
            }
            
            g.fillRect(0, 0, img.getWidth(null), img.getHeight(null));
        } finally {
            g.dispose();
        }
    }
1325363
function(tile) {
        tile.unload();
        tile.events.un({
            "loadstart": tile.onLoadStart,
            "loadend": tile.onLoadEnd,
            "unload": tile.onLoadEnd,
            "loaderror": tile.onLoadError,
            scope: this
        });
    }