| | import base64 |
| | import json |
| | import io |
| | import numpy as np |
| | from PIL import Image |
| | from pyodide import to_js, create_proxy |
| | import gc |
| | from js import ( |
| | console, |
| | document, |
| | devicePixelRatio, |
| | ImageData, |
| | Uint8ClampedArray, |
| | CanvasRenderingContext2D as Context2d, |
| | requestAnimationFrame, |
| | update_overlay, |
| | setup_overlay, |
| | window |
| | ) |
| |
|
| | PAINT_SELECTION = "selection" |
| | IMAGE_SELECTION = "canvas" |
| | BRUSH_SELECTION = "eraser" |
| | NOP_MODE = 0 |
| | PAINT_MODE = 1 |
| | IMAGE_MODE = 2 |
| | BRUSH_MODE = 3 |
| |
|
| |
|
| | def hold_canvas(): |
| | pass |
| |
|
| |
|
| | def prepare_canvas(width, height, canvas) -> Context2d: |
| | ctx = canvas.getContext("2d") |
| |
|
| | canvas.style.width = f"{width}px" |
| | canvas.style.height = f"{height}px" |
| |
|
| | canvas.width = width |
| | canvas.height = height |
| |
|
| | ctx.clearRect(0, 0, width, height) |
| |
|
| | return ctx |
| |
|
| |
|
| | |
| | |
| | |
| | def multi_canvas(layer, width=800, height=600): |
| | lst = [ |
| | CanvasProxy(document.querySelector(f"#canvas{i}"), width, height) |
| | for i in range(layer) |
| | ] |
| | return lst |
| |
|
| |
|
| | class CanvasProxy: |
| | def __init__(self, canvas, width=800, height=600) -> None: |
| | self.canvas = canvas |
| | self.ctx = prepare_canvas(width, height, canvas) |
| | self.width = width |
| | self.height = height |
| |
|
| | def clear_rect(self, x, y, w, h): |
| | self.ctx.clearRect(x, y, w, h) |
| |
|
| | def clear(self,): |
| | self.clear_rect(0, 0, self.canvas.width, self.canvas.height) |
| |
|
| | def stroke_rect(self, x, y, w, h): |
| | self.ctx.strokeRect(x, y, w, h) |
| |
|
| | def fill_rect(self, x, y, w, h): |
| | self.ctx.fillRect(x, y, w, h) |
| |
|
| | def put_image_data(self, image, x, y): |
| | data = Uint8ClampedArray.new(to_js(image.tobytes())) |
| | height, width, _ = image.shape |
| | image_data = ImageData.new(data, width, height) |
| | self.ctx.putImageData(image_data, x, y) |
| | del image_data |
| |
|
| | |
| | |
| | def draw_image(self,canvas, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight): |
| | self.ctx.drawImage(canvas, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight) |
| |
|
| | @property |
| | def stroke_style(self): |
| | return self.ctx.strokeStyle |
| |
|
| | @stroke_style.setter |
| | def stroke_style(self, value): |
| | self.ctx.strokeStyle = value |
| |
|
| | @property |
| | def fill_style(self): |
| | return self.ctx.strokeStyle |
| |
|
| | @fill_style.setter |
| | def fill_style(self, value): |
| | self.ctx.fillStyle = value |
| |
|
| |
|
| | |
| | class InfCanvas: |
| | def __init__( |
| | self, |
| | width, |
| | height, |
| | selection_size=256, |
| | grid_size=64, |
| | patch_size=4096, |
| | test_mode=False, |
| | ) -> None: |
| | assert selection_size < min(height, width) |
| | self.width = width |
| | self.height = height |
| | self.display_width = width |
| | self.display_height = height |
| | self.canvas = multi_canvas(5, width=width, height=height) |
| | setup_overlay(width,height) |
| | |
| | self.view_pos = [patch_size//2-width//2, patch_size//2-height//2] |
| | self.cursor = [ |
| | width // 2 - selection_size // 2, |
| | height // 2 - selection_size // 2, |
| | ] |
| | self.data = {} |
| | self.grid_size = grid_size |
| | self.selection_size_w = selection_size |
| | self.selection_size_h = selection_size |
| | self.patch_size = patch_size |
| | |
| | self.buffer = np.zeros((height, width, 4), dtype=np.uint8) |
| | self.sel_buffer = np.zeros((selection_size, selection_size, 4), dtype=np.uint8) |
| | self.sel_buffer_bak = np.zeros( |
| | (selection_size, selection_size, 4), dtype=np.uint8 |
| | ) |
| | self.sel_dirty = False |
| | self.buffer_dirty = False |
| | self.mouse_pos = [-1, -1] |
| | self.mouse_state = 0 |
| | |
| | self.test_mode = test_mode |
| | self.buffer_updated = False |
| | self.image_move_freq = 1 |
| | self.show_brush = False |
| | self.scale=1.0 |
| | self.eraser_size=32 |
| |
|
| | def reset_large_buffer(self): |
| | self.canvas[2].canvas.width=self.width |
| | self.canvas[2].canvas.height=self.height |
| | |
| | |
| | self.canvas[2].canvas.style.display="block" |
| | self.canvas[2].clear() |
| |
|
| | def draw_eraser(self, x, y): |
| | self.canvas[-2].clear() |
| | self.canvas[-2].fill_style = "#ffffff" |
| | self.canvas[-2].fill_rect(x-self.eraser_size//2,y-self.eraser_size//2,self.eraser_size,self.eraser_size) |
| | self.canvas[-2].stroke_rect(x-self.eraser_size//2,y-self.eraser_size//2,self.eraser_size,self.eraser_size) |
| |
|
| | def use_eraser(self,x,y): |
| | if self.sel_dirty: |
| | self.write_selection_to_buffer() |
| | self.draw_buffer() |
| | self.canvas[2].clear() |
| | self.buffer_dirty=True |
| | bx0,by0=int(x)-self.eraser_size//2,int(y)-self.eraser_size//2 |
| | bx1,by1=bx0+self.eraser_size,by0+self.eraser_size |
| | bx0,by0=max(0,bx0),max(0,by0) |
| | bx1,by1=min(self.width,bx1),min(self.height,by1) |
| | self.buffer[by0:by1,bx0:bx1,:]*=0 |
| | self.draw_buffer() |
| | self.draw_selection_box() |
| |
|
| | def setup_mouse(self): |
| | self.image_move_cnt = 0 |
| |
|
| | def get_mouse_mode(): |
| | mode = document.querySelector("#mode").value |
| | if mode == PAINT_SELECTION: |
| | return PAINT_MODE |
| | elif mode == IMAGE_SELECTION: |
| | return IMAGE_MODE |
| | return BRUSH_MODE |
| |
|
| | def get_event_pos(event): |
| | canvas = self.canvas[-1].canvas |
| | rect = canvas.getBoundingClientRect() |
| | x = (canvas.width * (event.clientX - rect.left)) / rect.width |
| | y = (canvas.height * (event.clientY - rect.top)) / rect.height |
| | return x, y |
| |
|
| | def handle_mouse_down(event): |
| | self.mouse_state = get_mouse_mode() |
| | if self.mouse_state==BRUSH_MODE: |
| | x,y=get_event_pos(event) |
| | self.use_eraser(x,y) |
| |
|
| | def handle_mouse_out(event): |
| | last_state = self.mouse_state |
| | self.mouse_state = NOP_MODE |
| | self.image_move_cnt = 0 |
| | if last_state == IMAGE_MODE: |
| | self.update_view_pos(0, 0) |
| | if True: |
| | self.clear_background() |
| | self.draw_buffer() |
| | self.reset_large_buffer() |
| | self.draw_selection_box() |
| | gc.collect() |
| | if self.show_brush: |
| | self.canvas[-2].clear() |
| | self.show_brush = False |
| |
|
| | def handle_mouse_up(event): |
| | last_state = self.mouse_state |
| | self.mouse_state = NOP_MODE |
| | self.image_move_cnt = 0 |
| | if last_state == IMAGE_MODE: |
| | self.update_view_pos(0, 0) |
| | if True: |
| | self.clear_background() |
| | self.draw_buffer() |
| | self.reset_large_buffer() |
| | self.draw_selection_box() |
| | gc.collect() |
| |
|
| | async def handle_mouse_move(event): |
| | x, y = get_event_pos(event) |
| | x0, y0 = self.mouse_pos |
| | xo = x - x0 |
| | yo = y - y0 |
| | if self.mouse_state == PAINT_MODE: |
| | self.update_cursor(int(xo), int(yo)) |
| | if True: |
| | |
| | |
| | if self.buffer_updated: |
| | self.draw_buffer() |
| | self.buffer_updated = False |
| | self.draw_selection_box() |
| | elif self.mouse_state == IMAGE_MODE: |
| | self.image_move_cnt += 1 |
| | if self.image_move_cnt == self.image_move_freq: |
| | self.draw_buffer() |
| | self.canvas[2].clear() |
| | self.draw_selection_box() |
| | self.update_view_pos(int(xo), int(yo)) |
| | self.cached_view_pos=tuple(self.view_pos) |
| | self.canvas[2].canvas.style.display="none" |
| | large_buffer=self.data2array(self.view_pos[0]-self.width//2,self.view_pos[1]-self.height//2,min(self.width*2,self.patch_size),min(self.height*2,self.patch_size)) |
| | self.canvas[2].canvas.width=large_buffer.shape[1] |
| | self.canvas[2].canvas.height=large_buffer.shape[0] |
| | |
| | |
| | self.canvas[2].put_image_data(large_buffer,0,0) |
| | else: |
| | self.update_view_pos(int(xo), int(yo), False) |
| | self.canvas[1].clear() |
| | self.canvas[1].draw_image(self.canvas[2].canvas, |
| | self.width//2+(self.view_pos[0]-self.cached_view_pos[0]),self.height//2+(self.view_pos[1]-self.cached_view_pos[1]), |
| | self.width,self.height, |
| | 0,0,self.width,self.height |
| | ) |
| | self.clear_background() |
| | |
| | elif self.mouse_state == BRUSH_MODE: |
| | self.use_eraser(x,y) |
| |
|
| | mode = document.querySelector("#mode").value |
| | if mode == BRUSH_SELECTION: |
| | self.draw_eraser(x,y) |
| | self.show_brush = True |
| | elif self.show_brush: |
| | self.canvas[-2].clear() |
| | self.show_brush = False |
| | self.mouse_pos[0] = x |
| | self.mouse_pos[1] = y |
| |
|
| | self.canvas[-1].canvas.addEventListener( |
| | "mousedown", create_proxy(handle_mouse_down) |
| | ) |
| | self.canvas[-1].canvas.addEventListener( |
| | "mousemove", create_proxy(handle_mouse_move) |
| | ) |
| | self.canvas[-1].canvas.addEventListener( |
| | "mouseup", create_proxy(handle_mouse_up) |
| | ) |
| | self.canvas[-1].canvas.addEventListener( |
| | "mouseout", create_proxy(handle_mouse_out) |
| | ) |
| | async def handle_mouse_wheel(event): |
| | x, y = get_event_pos(event) |
| | self.mouse_pos[0] = x |
| | self.mouse_pos[1] = y |
| | console.log(to_js(self.mouse_pos)) |
| | if event.deltaY>10: |
| | window.postMessage(to_js(["click","zoom_out", self.mouse_pos[0], self.mouse_pos[1]]),"*") |
| | elif event.deltaY<-10: |
| | window.postMessage(to_js(["click","zoom_in", self.mouse_pos[0], self.mouse_pos[1]]),"*") |
| | return False |
| | self.canvas[-1].canvas.addEventListener( |
| | "wheel", create_proxy(handle_mouse_wheel), False |
| | ) |
| | def clear_background(self): |
| | |
| | h, w, step = self.height, self.width, self.grid_size |
| | stride = step * 2 |
| | x0, y0 = self.view_pos |
| | x0 = (-x0) % stride |
| | y0 = (-y0) % stride |
| | if y0>=step: |
| | val0,val1=stride,step |
| | else: |
| | val0,val1=step,stride |
| | |
| | self.canvas[0].fill_style = "#ffffff" |
| | self.canvas[0].fill_rect(0, 0, w, h) |
| | self.canvas[0].fill_style = "#aaaaaa" |
| | for y in range(y0-stride, h + step, step): |
| | start = (x0 - val0) if y // step % 2 == 0 else (x0 - val1) |
| | for x in range(start, w + step, stride): |
| | self.canvas[0].fill_rect(x, y, step, step) |
| | self.canvas[0].stroke_rect(0, 0, w, h) |
| |
|
| | def refine_selection(self): |
| | h,w=self.selection_size_h,self.selection_size_w |
| | h=min(h,self.height) |
| | w=min(w,self.width) |
| | self.selection_size_h=h*8//8 |
| | self.selection_size_w=w*8//8 |
| | self.update_cursor(1,0) |
| | |
| |
|
| | def update_scale(self, scale, mx=-1, my=-1): |
| | self.sync_to_data() |
| | scaled_width=int(self.display_width*scale) |
| | scaled_height=int(self.display_height*scale) |
| | if max(scaled_height,scaled_width)>=self.patch_size*2-128: |
| | return |
| | if scaled_height<=self.selection_size_h or scaled_width<=self.selection_size_w: |
| | return |
| | if mx>=0 and my>=0: |
| | scaled_mx=mx/self.scale*scale |
| | scaled_my=my/self.scale*scale |
| | self.view_pos[0]+=int(mx-scaled_mx) |
| | self.view_pos[1]+=int(my-scaled_my) |
| | self.scale=scale |
| | for item in self.canvas: |
| | item.canvas.width=scaled_width |
| | item.canvas.height=scaled_height |
| | item.clear() |
| | update_overlay(scaled_width,scaled_height) |
| | self.width=scaled_width |
| | self.height=scaled_height |
| | self.data2buffer() |
| | self.clear_background() |
| | self.draw_buffer() |
| | self.update_cursor(1,0) |
| | self.draw_selection_box() |
| |
|
| | def update_view_pos(self, xo, yo, update=True): |
| | |
| | |
| | if self.sel_dirty: |
| | self.write_selection_to_buffer() |
| | if self.buffer_dirty: |
| | self.buffer2data() |
| | self.view_pos[0] -= xo |
| | self.view_pos[1] -= yo |
| | if update: |
| | self.data2buffer() |
| | |
| |
|
| | def update_cursor(self, xo, yo): |
| | if abs(xo) + abs(yo) == 0: |
| | return |
| | if self.sel_dirty: |
| | self.write_selection_to_buffer() |
| | self.cursor[0] += xo |
| | self.cursor[1] += yo |
| | self.cursor[0] = max(min(self.width - self.selection_size_w, self.cursor[0]), 0) |
| | self.cursor[1] = max(min(self.height - self.selection_size_h, self.cursor[1]), 0) |
| | |
| |
|
| | def data2buffer(self): |
| | x, y = self.view_pos |
| | h, w = self.height, self.width |
| | if h!=self.buffer.shape[0] or w!=self.buffer.shape[1]: |
| | self.buffer=np.zeros((self.height, self.width, 4), dtype=np.uint8) |
| | |
| | for i in range(4): |
| | pos_src, pos_dst, data = self.select(x, y, i) |
| | xs0, xs1 = pos_src[0] |
| | ys0, ys1 = pos_src[1] |
| | xd0, xd1 = pos_dst[0] |
| | yd0, yd1 = pos_dst[1] |
| | self.buffer[yd0:yd1, xd0:xd1, :] = data[ys0:ys1, xs0:xs1, :] |
| |
|
| | def data2array(self, x, y, w, h): |
| | |
| | |
| | ret=np.zeros((h, w, 4), dtype=np.uint8) |
| | |
| | for i in range(4): |
| | pos_src, pos_dst, data = self.select(x, y, i, w, h) |
| | xs0, xs1 = pos_src[0] |
| | ys0, ys1 = pos_src[1] |
| | xd0, xd1 = pos_dst[0] |
| | yd0, yd1 = pos_dst[1] |
| | ret[yd0:yd1, xd0:xd1, :] = data[ys0:ys1, xs0:xs1, :] |
| | return ret |
| |
|
| | def buffer2data(self): |
| | x, y = self.view_pos |
| | h, w = self.height, self.width |
| | |
| | for i in range(4): |
| | pos_src, pos_dst, data = self.select(x, y, i) |
| | xs0, xs1 = pos_src[0] |
| | ys0, ys1 = pos_src[1] |
| | xd0, xd1 = pos_dst[0] |
| | yd0, yd1 = pos_dst[1] |
| | data[ys0:ys1, xs0:xs1, :] = self.buffer[yd0:yd1, xd0:xd1, :] |
| | self.buffer_dirty = False |
| |
|
| | def select(self, x, y, idx, width=0, height=0): |
| | if width==0: |
| | w, h = self.width, self.height |
| | else: |
| | w, h = width, height |
| | lst = [(0, 0), (0, h), (w, 0), (w, h)] |
| | if idx == 0: |
| | x0, y0 = x % self.patch_size, y % self.patch_size |
| | x1 = min(x0 + w, self.patch_size) |
| | y1 = min(y0 + h, self.patch_size) |
| | elif idx == 1: |
| | y += h |
| | x0, y0 = x % self.patch_size, y % self.patch_size |
| | x1 = min(x0 + w, self.patch_size) |
| | y1 = max(y0 - h, 0) |
| | elif idx == 2: |
| | x += w |
| | x0, y0 = x % self.patch_size, y % self.patch_size |
| | x1 = max(x0 - w, 0) |
| | y1 = min(y0 + h, self.patch_size) |
| | else: |
| | x += w |
| | y += h |
| | x0, y0 = x % self.patch_size, y % self.patch_size |
| | x1 = max(x0 - w, 0) |
| | y1 = max(y0 - h, 0) |
| | xi, yi = x // self.patch_size, y // self.patch_size |
| | cur = self.data.setdefault( |
| | (xi, yi), np.zeros((self.patch_size, self.patch_size, 4), dtype=np.uint8) |
| | ) |
| | x0_img, y0_img = lst[idx] |
| | x1_img = x0_img + x1 - x0 |
| | y1_img = y0_img + y1 - y0 |
| | sort = lambda a, b: ((a, b) if a < b else (b, a)) |
| | return ( |
| | (sort(x0, x1), sort(y0, y1)), |
| | (sort(x0_img, x1_img), sort(y0_img, y1_img)), |
| | cur, |
| | ) |
| |
|
| | def draw_buffer(self): |
| | self.canvas[1].clear() |
| | self.canvas[1].put_image_data(self.buffer, 0, 0) |
| |
|
| | def fill_selection(self, img): |
| | self.sel_buffer = img |
| | self.sel_dirty = True |
| |
|
| | def draw_selection_box(self): |
| | x0, y0 = self.cursor |
| | w, h = self.selection_size_w, self.selection_size_h |
| | if self.sel_dirty: |
| | self.canvas[2].clear() |
| | self.canvas[2].put_image_data(self.sel_buffer, x0, y0) |
| | self.canvas[-1].clear() |
| | self.canvas[-1].stroke_style = "#0a0a0a" |
| | self.canvas[-1].stroke_rect(x0, y0, w, h) |
| | self.canvas[-1].stroke_style = "#ffffff" |
| | offset=round(self.scale) if self.scale>1.0 else 1 |
| | self.canvas[-1].stroke_rect(x0 - offset, y0 - offset, w + offset*2, h + offset*2) |
| | self.canvas[-1].stroke_style = "#000000" |
| | self.canvas[-1].stroke_rect(x0 - offset*2, y0 - offset*2, w + offset*4, h + offset*4) |
| |
|
| | def write_selection_to_buffer(self): |
| | x0, y0 = self.cursor |
| | x1, y1 = x0 + self.selection_size_w, y0 + self.selection_size_h |
| | self.buffer[y0:y1, x0:x1] = self.sel_buffer |
| | self.sel_dirty = False |
| | self.sel_buffer = np.zeros( |
| | (self.selection_size_h, self.selection_size_w, 4), dtype=np.uint8 |
| | ) |
| | self.buffer_dirty = True |
| | self.buffer_updated = True |
| | |
| |
|
| | def read_selection_from_buffer(self): |
| | x0, y0 = self.cursor |
| | x1, y1 = x0 + self.selection_size_w, y0 + self.selection_size_h |
| | self.sel_buffer = self.buffer[y0:y1, x0:x1] |
| | self.sel_dirty = False |
| |
|
| | def base64_to_numpy(self, base64_str): |
| | try: |
| | data = base64.b64decode(str(base64_str)) |
| | pil = Image.open(io.BytesIO(data)) |
| | arr = np.array(pil) |
| | ret = arr |
| | except: |
| | ret = np.tile( |
| | np.array([255, 0, 0, 255], dtype=np.uint8), |
| | (self.selection_size_h, self.selection_size_w, 1), |
| | ) |
| | return ret |
| |
|
| | def numpy_to_base64(self, arr): |
| | out_pil = Image.fromarray(arr) |
| | out_buffer = io.BytesIO() |
| | out_pil.save(out_buffer, format="PNG") |
| | out_buffer.seek(0) |
| | base64_bytes = base64.b64encode(out_buffer.read()) |
| | base64_str = base64_bytes.decode("ascii") |
| | return base64_str |
| | |
| | def sync_to_data(self): |
| | if self.sel_dirty: |
| | self.write_selection_to_buffer() |
| | self.canvas[2].clear() |
| | self.draw_buffer() |
| | if self.buffer_dirty: |
| | self.buffer2data() |
| | |
| | def sync_to_buffer(self): |
| | if self.sel_dirty: |
| | self.canvas[2].clear() |
| | self.write_selection_to_buffer() |
| | self.draw_buffer() |
| |
|
| | def resize(self,width,height,scale=None,**kwargs): |
| | self.display_width=width |
| | self.display_height=height |
| | for canvas in self.canvas: |
| | prepare_canvas(width=width,height=height,canvas=canvas.canvas) |
| | setup_overlay(width,height) |
| | if scale is None: |
| | scale=1 |
| | self.update_scale(scale) |
| |
|
| |
|
| | def save(self): |
| | self.sync_to_data() |
| | state={} |
| | state["width"]=self.display_width |
| | state["height"]=self.display_height |
| | state["selection_width"]=self.selection_size_w |
| | state["selection_height"]=self.selection_size_h |
| | state["view_pos"]=self.view_pos[:] |
| | state["cursor"]=self.cursor[:] |
| | state["scale"]=self.scale |
| | keys=list(self.data.keys()) |
| | data={} |
| | for key in keys: |
| | if self.data[key].sum()>0: |
| | data[f"{key[0]},{key[1]}"]=self.numpy_to_base64(self.data[key]) |
| | state["data"]=data |
| | return json.dumps(state) |
| |
|
| | def load(self, state_json): |
| | self.reset() |
| | state=json.loads(state_json) |
| | self.display_width=state["width"] |
| | self.display_height=state["height"] |
| | self.selection_size_w=state["selection_width"] |
| | self.selection_size_h=state["selection_height"] |
| | self.view_pos=state["view_pos"][:] |
| | self.cursor=state["cursor"][:] |
| | self.scale=state["scale"] |
| | self.resize(state["width"],state["height"],scale=state["scale"]) |
| | for k,v in state["data"].items(): |
| | key=tuple(map(int,k.split(","))) |
| | self.data[key]=self.base64_to_numpy(v) |
| | self.data2buffer() |
| | self.display() |
| |
|
| | def display(self): |
| | self.clear_background() |
| | self.draw_buffer() |
| | self.draw_selection_box() |
| |
|
| | def reset(self): |
| | self.data.clear() |
| | self.buffer*=0 |
| | self.buffer_dirty=False |
| | self.buffer_updated=False |
| | self.sel_buffer*=0 |
| | self.sel_dirty=False |
| | self.view_pos = [0, 0] |
| | self.clear_background() |
| | for i in range(1,len(self.canvas)-1): |
| | self.canvas[i].clear() |
| |
|
| | def export(self): |
| | self.sync_to_data() |
| | xmin, xmax, ymin, ymax = 0, 0, 0, 0 |
| | if len(self.data.keys()) == 0: |
| | return np.zeros( |
| | (self.selection_size_h, self.selection_size_w, 4), dtype=np.uint8 |
| | ) |
| | for xi, yi in self.data.keys(): |
| | buf = self.data[(xi, yi)] |
| | if buf.sum() > 0: |
| | xmin = min(xi, xmin) |
| | xmax = max(xi, xmax) |
| | ymin = min(yi, ymin) |
| | ymax = max(yi, ymax) |
| | yn = ymax - ymin + 1 |
| | xn = xmax - xmin + 1 |
| | image = np.zeros( |
| | (yn * self.patch_size, xn * self.patch_size, 4), dtype=np.uint8 |
| | ) |
| | for xi, yi in self.data.keys(): |
| | buf = self.data[(xi, yi)] |
| | if buf.sum() > 0: |
| | y0 = (yi - ymin) * self.patch_size |
| | x0 = (xi - xmin) * self.patch_size |
| | image[y0 : y0 + self.patch_size, x0 : x0 + self.patch_size] = buf |
| | ylst, xlst = image[:, :, -1].nonzero() |
| | if len(ylst) > 0: |
| | yt, xt = ylst.min(), xlst.min() |
| | yb, xb = ylst.max(), xlst.max() |
| | image = image[yt : yb + 1, xt : xb + 1] |
| | return image |
| | else: |
| | return np.zeros( |
| | (self.selection_size_h, self.selection_size_w, 4), dtype=np.uint8 |
| | ) |
| |
|
