pyscratch-pysc 1.0.3__py3-none-any.whl

pyscratch/tools/sprite_preview/right_panel/back_button.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+from typing import List, Tuple
+import pyscratch as pysc
+from pyscratch.sprite import Sprite
+from settings import *
+from .file_display import FileDisplay
+w, h = 50*1.62, 50
+colour = (127, 127, 127)
+button = pysc.create_rect_sprite(colour, w, h)
+button.set_xy((900, 550))
+pysc.game.change_layer(button, 1)
+
+#button.when_game_start().add_handler(lambda: button.lock_to(pysc.game.shared_data['folder_navigation'], offset=(0,0)))
+
+
+
+def on_click():
+    if pysc.game.shared_data['cut_or_nav_mode'] == 'nav':
+        pysc.game.broadcast_message('back_nav', None)
+    else:
+        #pysc.game.broadcast_message('cut', None)
+        pysc.game.broadcast_message('cut_or_nav_mode_change', 'nav')
+
+button.when_this_sprite_clicked().add_handler(on_click)
+
+
+def on_msg_mode_change(mode):
+    pysc.game.shared_data['cut_or_nav_mode'] = mode
+    if mode == 'nav':
+        button.write_text("Back", DEFAULT_FONT24, offset=(w/2, h/2))
+    else:
+        button.write_text("Back", DEFAULT_FONT24, offset=(w/2, h/2))
+
+
+button.when_receive_message('cut_or_nav_mode_change').add_handler(on_msg_mode_change)

pyscratch/tools/sprite_preview/right_panel/cut_button.py

@@ -0,0 +1,32 @@
+from pathlib import Path
+from typing import List, Tuple
+import pyscratch as pysc
+from pyscratch.sprite import Sprite
+from settings import *
+from .file_display import FileDisplay
+w, h = 50*1.62, 50
+colour = (127, 127, 127)
+button = pysc.create_rect_sprite(colour, w, h)
+button.set_xy((1100, 550))
+pysc.game.change_layer(button, 1)
+
+def on_click():
+    if pysc.game.shared_data['cut_or_nav_mode'] == 'nav':
+        #pysc.game.broadcast_message('cut_or_nav_mode_change', 'cut')
+        pass
+    else:
+        pysc.game.broadcast_message('cut', None)
+        #pysc.game.broadcast_message('cut_or_nav_mode_change', 'nav')
+
+button.when_this_sprite_clicked().add_handler(on_click)
+
+
+def on_msg_mode_change(mode):
+    pysc.game.shared_data['cut_or_nav_mode'] = mode
+    if mode == 'nav':
+        button.write_text("...", DEFAULT_FONT24, offset=(w/2, h/2))
+    else:
+        button.write_text("Cut", DEFAULT_FONT24, offset=(w/2, h/2))
+
+
+button.when_receive_message('cut_or_nav_mode_change').add_handler(on_msg_mode_change)

pyscratch/tools/sprite_preview/right_panel/cut_parameter_fitting.py

@@ -0,0 +1,152 @@
+import pygame
+import numpy as np
+from settings import *
+import pyscratch as pysc
+game = pysc.game 
+xpos2 = 1050
+
+
+w, h = 50*1.62, 40
+colour = (255, 127, 127)
+button = pysc.create_rect_sprite(colour, w, h)
+button.set_xy((1200, 650))
+button.write_text("Fit", DEFAULT_FONT24, offset=(w/2, h/2))
+pysc.game.change_layer(button, 1)
+
+
+
+def on_click():
+    if not 'image_on_right_display' in pysc.game.shared_data:
+        pysc.game.broadcast_message('warning', 'image not selected' )
+        return 
+            
+    if game['offset_x'] is None: return 
+    if game['offset_y'] is None: return 
+    if game['size_x'] is None: return 
+    if game['size_y'] is None: return 
+
+
+    img: pygame.Surface = game['image_on_right_display']
+
+
+    fitter = ParamsFitter(img)
+
+    n_col, pixel_x, offset_x = fitter.find_best_x(game['offset_x'], game['limit_x'])
+    n_row, pixel_y, offset_y = fitter.find_best_y(game['offset_y'], game['limit_y'])
+
+    if (n_col and pixel_x and (not offset_x is None)):
+        game['n_col'] = n_col
+        game['pixel_x'] = pixel_x
+        game['offset_x'] = offset_x
+        game['size_x'] = min(game['limit_x'] - game['offset_x']+1, game['size_x'])
+
+    if (n_row and pixel_y and (not offset_y is None)):
+        game['n_row'] = n_row
+        game['pixel_y'] = pixel_y
+        game['offset_y'] = offset_y
+        game['offset_y'] = offset_y
+        game['size_y'] = min(game['limit_y'] - game['offset_y']+1, game['size_y'])
+
+
+    #game.broadcast_message('n_row_change')
+    #game.broadcast_message('n_col_change')
+
+    #game.broadcast_message('pixel_x_change')
+
+    #game.broadcast_message('pixel_y_change')
+
+    #game.broadcast_message('offset_x_change')
+    #game.broadcast_message('offset_y_change')
+
+    
+
+
+button.when_this_sprite_clicked().add_handler(on_click)
+
+from itertools import product
+class ParamsFitter:
+
+    def __init__(self, surface):
+
+        self.surface = surface
+        self.arr = pygame.surfarray.pixels_alpha(surface)
+
+        self.yslits = ParamsFitter.get_slit_values(self.arr.mean(0))
+        self.xslits = ParamsFitter.get_slit_values(self.arr.mean(1))
+    
+    def num_frames_x(self, offset, limit):
+        # TODO: think about it: is the boundary correct?
+        return ParamsFitter.get_num_frames(self.xslits[offset: limit+2])
+    
+    def num_frames_y(self, offset, limit):
+        return ParamsFitter.get_num_frames(self.yslits[offset: limit+2])
+    
+    def find_best_x(self, offset_centre: int, limit:int):
+        offset_centre = int(offset_centre)
+        limit = int(limit)
+
+        return ParamsFitter.search_best(self.xslits[: limit+2], offset_centre)
+    
+    def find_best_y(self, offset_centre: int, limit:int):
+        offset_centre = int(offset_centre)
+        limit = int(limit)
+        return ParamsFitter.search_best(self.yslits[: limit+2], offset_centre)
+    
+    @staticmethod
+    def search_best(slit_values, centre_offset, step_range_ratio=0.1, offset_range_ratio=0.1):
+        #print(len(slit_values))
+        n_frame = int(ParamsFitter.get_num_frames(slit_values[centre_offset:]))
+        print(ParamsFitter.get_num_frames_rank(slit_values[centre_offset:]))
+
+        # TODO: possibly DIV BY ZERO?
+        step_size = max(1, (len(slit_values[centre_offset:])-1)/n_frame )
+        
+        step_range = round(step_size*step_range_ratio)
+        offset_range = round(step_size*offset_range_ratio)
+
+        step_size = round(step_size)
+
+        # TODO: very easy to go out of boundary
+        step_sizes = range(step_size+step_range+1, max(0, step_size-step_range), -1)
+        offsets = range(max(0,centre_offset-offset_range), centre_offset+offset_range+1)
+
+        vmin = np.inf
+        best_ss = None
+        best_os = None
+        for ss, os in product(step_sizes, offsets):
+
+            n, v = ParamsFitter.eval_cut(slit_values, ss, os)
+            #print(f"trying: pixel_sz:{ss}, offset:{os} -> {n, v}")
+            if not n == n_frame: continue
+            if v < vmin:
+                best_ss = ss
+                best_os = os
+                vmin = v
+            #print(ss, os, v)
+
+
+
+        print(f"n_frame: {n_frame}, pixel_sz:{best_ss}, offset:{best_os} -> {vmin}")
+        return n_frame, best_ss, best_os
+        
+    @staticmethod
+    def get_num_frames(slit_values):
+        return np.argmax(np.abs(np.fft.fft(slit_values))[1:len(slit_values)//2])+1 
+        
+    @staticmethod
+    def get_num_frames_rank(slit_values):
+        return np.argsort(np.abs(np.fft.fft(slit_values))[1:len(slit_values)//2])+1 
+    
+
+    @staticmethod
+    def get_rough_est_num_pixel(slit_values):
+        return (len(slit_values)-1)/ParamsFitter.get_num_frames(slit_values)
+
+    @staticmethod
+    def eval_cut(slit_values, step_size, offset=0):
+        cut_indices = np.arange(offset, len(slit_values), step_size)
+        return len(cut_indices)-1, slit_values[cut_indices].mean()   
+ 
+    @staticmethod
+    def get_slit_values(axis_mean):
+        return np.r_[[0], (axis_mean[1:]+axis_mean[:-1]), [0]]

pyscratch/tools/sprite_preview/right_panel/cut_parameters.py

@@ -0,0 +1,42 @@
+from utils.input_box import IntegerInputBox, FloatInputBoxHoriLabel
+import pyscratch as pysc
+from settings import *
+
+xpos1 = 830
+xpos2 = 1050
+
+offset_x_input = IntegerInputBox('offset_x', 'offset_x_change', "0", 80)
+offset_x_input.set_xy((xpos1, 605))
+
+
+offset_y_input = IntegerInputBox('offset_y', 'offset_y_change', "0", 80)
+offset_y_input.set_xy((xpos2, 605))
+
+pysc.game['limit_x'] = None
+pysc.game['limit_y'] = None
+
+pysc.game['size_x'] = None
+pysc.game['size_y'] = None
+
+
+
+row_input = IntegerInputBox('n_row', "n_row_change", "", 80)
+row_input.set_xy((xpos1, 650))
+
+col_input = IntegerInputBox('n_col', "n_col_change", "", 80)
+col_input.set_xy((xpos2, 650))
+
+
+pixel_x_input = IntegerInputBox('pixel_x', 'pixel_x_change', "0", 80)
+pixel_x_input.set_xy((xpos1, 695))
+
+pixel_y_input = IntegerInputBox('pixel_y', 'pixel_y_change', "0", 80)
+pixel_y_input.set_xy((xpos2, 695))
+
+
+pysc.game.change_layer(offset_x_input, 1)
+pysc.game.change_layer(offset_y_input, 1)
+pysc.game.change_layer(row_input, 1)
+pysc.game.change_layer(col_input, 1)
+pysc.game.change_layer(pixel_x_input, 1)
+pysc.game.change_layer(pixel_y_input, 1)

pyscratch/tools/sprite_preview/right_panel/file_display.py

@@ -0,0 +1,84 @@
+from pathlib import Path
+from typing import Tuple
+import pyscratch as pysc
+
+from utils.render_wrapped_file_name import render_wrapped_file_name
+from settings import *
+
+width, height = 100, 140
+colour = (130, 130, 130)
+
+spacing = 10
+n_cols = 5
+
+def try_load_image(path):
+    try: 
+        return pysc.load_image(path)
+    except:
+        return None
+
+
+
+def FileDisplay(path: Path, order: int, panel_top_left):
+    sprite = pysc.create_rect_sprite(colour, width, height)
+    
+    # set the position
+
+    panel_x, panel_y = panel_top_left
+    sprite.x = spacing+(order%n_cols)*(width+spacing)+panel_x +width/2
+    sprite.y = spacing+(order//n_cols)*(height+spacing)+panel_y +height/2
+
+    # set the display
+
+    surface = try_load_image(path)
+    if not surface: 
+        # TODO: messy af
+        if path.is_file():
+            sprite.remove()
+            return None
+        
+        text = render_wrapped_file_name(path.name+'/', 8, DEFAULT_FONT24)
+        sprite.draw(text, offset=(width/2, height/2) )
+        #sprite.write_text(path.name+'/', DEFAULT_FONT24, offset=(width/2, height/2))
+        
+    else: 
+        image_margin = 20
+        text_height = 20
+        fit = "horizontal" if surface.get_width() >= surface.get_height() else "vertical"
+        surface = pysc.scale_to_fit_aspect(surface, (width-image_margin, height-text_height-image_margin ), fit)
+        sprite.draw(surface, (width/2, (height-text_height)/2))
+        
+        text = render_wrapped_file_name(path.name, 8, DEFAULT_FONT24, color= (255, 255, 255), max_lines=2)
+        sprite.draw(text,offset=(width/2, height-20), reset=False)
+
+
+
+    sprite.sprite_data['is_file'] = path.is_file()
+
+
+    def on_click():
+        if not path.is_file():
+            pysc.game.broadcast_message('folder_update', path)
+        else:
+            pysc.game.broadcast_message('image_selected', path)
+            #pysc.game.broadcast_message('cut_or_nav_mode_change', 'cut')
+
+
+
+    sprite.when_this_sprite_clicked().add_handler(on_click)
+
+
+    def on_msg_mode_change(mode):
+        if mode == 'nav':
+            sprite.show()
+            #pysc.game.bring_to_front(sprite)
+        else:
+            sprite.hide()
+
+    sprite.when_receive_message('cut_or_nav_mode_change').add_handler(on_msg_mode_change)
+
+
+
+
+    return sprite
+    

pyscratch/tools/sprite_preview/right_panel/file_display_area.py

@@ -0,0 +1,57 @@
+from pathlib import Path
+from typing import List, Tuple, cast
+import pyscratch as pysc
+from pyscratch.sprite import Sprite
+from settings import *
+from .file_display import FileDisplay
+
+width, height = RIGHT_PANEL_WIDTH, SCREEN_HEIGHT - PANEL_MARGIN - BOTTOM_RIGHT_PANEL_HEIGHT
+
+colour = 255, 255, 255
+folder_navigation = pysc.create_rect_sprite(colour, width, height)
+
+folder_navigation.set_xy((SCREEN_WIDTH - PANEL_MARGIN - RIGHT_PANEL_WIDTH/2,  SCREEN_HEIGHT/2-BOTTOM_RIGHT_PANEL_HEIGHT/2))
+
+topleft = folder_navigation.x-width/2, folder_navigation.y-height/2
+
+folder_navigation['file_display_list'] = []
+
+def on_msg_folder_update(path: Path):
+    #folder_navigation.sprite_data['path'] = path
+    pysc.game.shared_data['path'] = path
+
+    for fdisp in folder_navigation['file_display_list']:
+        fdisp.remove()
+
+    folder_navigation['file_display_list']  = []
+    file_display_list = folder_navigation['file_display_list'] 
+
+    c = 0
+    for f in path.iterdir():
+        fdisp = FileDisplay(f, c, topleft)
+        if fdisp: 
+            c+=1
+            file_display_list.append(fdisp)
+
+folder_navigation.when_receive_message('folder_update').add_handler(on_msg_folder_update)
+
+
+def on_msg_back_nav(_):
+    path: Path = pysc.game['path']
+    pysc.game.broadcast_message('folder_update', path.parent)
+
+
+    
+folder_navigation.when_receive_message('back_nav').add_handler(on_msg_back_nav)
+
+
+
+def on_msg_mode_change(mode):
+    if mode == 'nav':
+        folder_navigation.show()
+        pysc.game.move_to_back(folder_navigation)
+    else:
+        folder_navigation.hide()
+
+folder_navigation.when_receive_message('cut_or_nav_mode_change').add_handler(on_msg_mode_change)
+pysc.game['folder_navigation'] = folder_navigation

pyscratch/tools/sprite_preview/right_panel/spritesheet_view.py

@@ -0,0 +1,262 @@
+"""
+pysc.game.broadcast_message
+    ("cut_sprite_frame_drop", dict(sprite=sprite, position=pysc.get_mouse_pos()))
+
+"""
+from pathlib import Path
+from typing import List, Tuple, cast
+
+import numpy as np
+from pygame import Surface
+import pyscratch as pysc
+from settings import *
+game = pysc.game
+width, height = RIGHT_PANEL_WIDTH, SCREEN_HEIGHT - PANEL_MARGIN - BOTTOM_RIGHT_PANEL_HEIGHT
+
+colour = 255, 255, 255, 255
+ss_view = pysc.create_rect_sprite(colour, width, height)
+
+ss_view.set_xy((SCREEN_WIDTH - PANEL_MARGIN - RIGHT_PANEL_WIDTH/2,  SCREEN_HEIGHT/2-BOTTOM_RIGHT_PANEL_HEIGHT/2))
+#ss_view.set_draggable(False)
+#topleft = ss_view.x-width/2, ss_view.y-height/2
+pysc.game['ss_view'] = ss_view
+
+def topleft():
+    return ss_view.x-width/2, ss_view.y-height/2
+ss_view['frame_list'] = []
+
+pysc.game['ss_view_topleft'] = topleft()
+pysc.game['ss_view_buttom_right'] = ss_view.x+width/2, ss_view.y+height/2
+
+
+
+ss_view['spritesheet_sprite'] = None
+pysc.game['ss_sprite'] = None
+def on_msg_mode_change(mode):
+    if not mode == 'nav':
+        ss_view.show()
+        pysc.game.move_to_back(ss_view)
+        for f in ss_view.sprite_data['frame_list']:
+            f.show()
+
+    else:
+        ss_view.hide()
+        for f in ss_view.sprite_data['frame_list']:
+            f.hide()
+        if ss_sprite := ss_view['spritesheet_sprite']:
+            ss_sprite.hide()
+            
+
+ss_view.when_receive_message('cut_or_nav_mode_change').add_handler(on_msg_mode_change)
+
+def try_load_image(path):
+    try: 
+        return pysc.load_image(path)
+    except:
+        return None
+
+
+def on_msg_image_selected(path):
+    
+    for f in ss_view['frame_list']:
+        f.remove()
+    ss_view['frame_list'] = []
+
+    img = try_load_image(path)
+    if img: 
+        pysc.game.shared_data['image_on_right_display'] = img
+
+        if ss_sprite := ss_view['spritesheet_sprite']:
+            ss_sprite.remove()
+
+        ss_view['spritesheet_sprite'] = pysc.Sprite({'a':[img]})
+
+        ss_sprite:pysc.Sprite = ss_view['spritesheet_sprite']
+
+        pysc.game['ss_sprite'] = ss_sprite
+        ss_sprite.oob_limit=np.inf
+        ss_sprite['original_width'] = img.get_width()
+        ss_sprite['original_height'] = img.get_height()
+        game.change_layer(ss_sprite, 0)
+
+        
+        #ss_sprite.lock_to(ss_view, offset=(0,0)) 
+        #ss_sprite.set_xy((0,0))
+
+        ss_sprite.set_xy((ss_view.rect.centerx, ss_view.rect.centery))
+        ss_sprite.set_draggable(True) #TODO: dragging a locked sprite leads to unexpected behaviour
+
+        ss_sprite._drawing_manager.set_mask_threshold(-1)
+
+
+        pysc.game.broadcast_message('cut_or_nav_mode_change', 'cut')
+    pass
+
+ss_view.when_receive_message('image_selected').add_handler(on_msg_image_selected)
+from itertools import product
+def on_msg_cut(_):
+    ss_view.draw(pysc.create_rect((0,0,0,0), 1, 1)) # reset
+
+    if not 'image_on_right_display' in pysc.game.shared_data:
+        pysc.game.broadcast_message('warning', 'image not selected' )
+        return 
+    
+    for f in ss_view['frame_list']:
+        f.remove()
+    ss_view['frame_list'] = []
+
+    
+    if ss_sprite := ss_view['spritesheet_sprite']:
+        ss_sprite.hide()
+    
+
+    spritesheet: pygame.Surface = pysc.game.shared_data['image_on_right_display'] 
+
+    n_row =  pysc.game.shared_data['n_row'] 
+    n_col =  pysc.game.shared_data['n_col'] 
+
+    if not n_row:
+        print('invalid n_row')
+        pysc.game.broadcast_message('warning', 'invalid n_row' )
+        return
+    
+    if not n_col:
+        print('invalid n_col')
+        pysc.game.broadcast_message('warning', 'invalid n_col' )
+        return
+    n_row = int(n_row)
+    n_col = int(n_col)
+    print(game['offset_x'], game['offset_y'], game['size_x'], game['size_y'])
+    spritesheet_to_cut = spritesheet.subsurface(game['offset_x'], game['offset_y'], game['size_x'], game['size_y'])
+
+    for i, (r, c) in enumerate(product(range(n_row), range(n_col))):
+        frame = pysc.get_frame_from_sprite_sheet_by_frame_size(spritesheet_to_cut, game['pixel_x'], game['pixel_y'], c, r)
+        sprite = SpriteFrameAfterCut(frame, i, ss_sprite.scale_factor, n_col)
+        ss_view['frame_list'].append(sprite)
+
+ss_view.when_receive_message('cut').add_handler(on_msg_cut)
+
+
+
+def SpriteFrameAfterCut(surface: Surface, order, scale_factor, n_col):
+    w, h = surface.get_width()*scale_factor, surface.get_height()*scale_factor
+    sprite = pysc.Sprite({'always':[surface]})
+    sprite.oob_limit = np.inf
+    sprite.scale_by(scale_factor)
+
+
+    spacing = 0
+    lt = topleft()
+    x = spacing+(order%n_col)*(w + spacing)+lt[0] +w/2
+    y = spacing+(order//n_col)*(h+spacing)+lt[1] +h/2
+    
+    sprite['x'] = x
+    sprite['y'] = y
+
+    sprite.set_xy((x,y))
+    sprite.set_draggable(True) 
+
+
+
+    def on_mouse_release():
+
+        pysc.game.broadcast_message("cut_sprite_frame_drop", dict(surface=surface, sprite=sprite, position=pysc.get_mouse_pos()))
+        pass
+
+
+    
+    pysc.game.when_this_sprite_click_released(sprite).add_handler(on_mouse_release)
+
+
+    return sprite
+
+
+
+# TODO: The scrolling becomes hard to use because touching only happens in the non-transparent pixels
+
+
+def on_scroll(updown):
+    #if updown.
+    ss_sprite:pysc.Sprite = ss_view['spritesheet_sprite']
+    if not ss_sprite: return
+    if not ss_sprite.is_touching_mouse():
+        return
+    
+    if updown == 'up':
+        ss_sprite.scale_by(1.05)
+    else:
+        ss_sprite.scale_by(1/1.05)
+    
+    pysc.game.broadcast_message("ss_sprite_scale_change")
+
+pysc.game.when_mouse_scroll([ss_view]).add_handler(on_scroll)
+
+
+
+def draw_cutting_rect(surface, colour, x0, y0, x1, y1, n_row, n_col):
+
+    n_row = 1 if not n_row else n_row
+    n_col = 1 if not n_col else n_col
+
+    x0, x1 = min(x0, x1), max(x0, x1)
+    y0, y1 = min(y0, y1), max(y0, y1)
+
+    n_line_h = n_row - 1
+    n_line_v = n_col - 1
+
+
+    pygame.draw.lines(surface, colour, True, [(x0, y0), (x0, y1), (x1, y1), (x1, y0)])
+
+    x_step = (x1 - x0)/n_col # vertical lines
+    y_step = (y1 - y0)/n_row # horizontal lines
+    # 
+    for lx in range(int(n_line_v)):
+        xpos = (1+lx)*x_step 
+        xpos += x0
+        pygame.draw.line(surface, colour, (xpos, y0), (xpos, y1))
+
+    for ly in range(int(n_line_h)):
+        ypos = (1+ly)*y_step 
+        ypos += y0
+        pygame.draw.line(surface, colour, (x0, ypos), (x1, ypos))
+
+    return x_step, y_step
+
+
+
+    
+def draw_selection_rect():
+    cir0, cir1 = pysc.game['c0'], pysc.game['c1']
+    while True: 
+        yield 1/30
+        ss_sprite:pysc.Sprite = ss_view['spritesheet_sprite']
+        if not ss_sprite: 
+            continue
+
+        if game['pixel_x'] is None: continue
+        if game['pixel_y'] is None: continue
+
+        ss_view._drawing_manager.frames[0].fill((255,255,255))
+
+        n_col = 1 if not pysc.game['n_col'] else pysc.game['n_col']
+        n_row = 1 if not pysc.game['n_row'] else pysc.game['n_row']
+
+
+        # top left of the selected rect
+        gx0 =  game['offset_x']*ss_sprite.scale_factor + ss_sprite.rect.left  - ss_view.rect.left
+        gy0 = game['offset_y']*ss_sprite.scale_factor + ss_sprite.rect.top  - ss_view.rect.top
+        
+        gx1 = gx0 + game['pixel_x']*n_col*ss_sprite.scale_factor 
+        gy1 = gy0 + game['pixel_y']*n_row*ss_sprite.scale_factor
+
+
+        #pygame.draw.lines(ss_view._drawing_manager.frames[0], (0,0,0), True, [(gx0, gy0), (gx0, gy1), (gx1, gy1), (gx1, gy0)])
+
+        draw_cutting_rect(
+            ss_view._drawing_manager.frames[0],
+            (0,0,0),
+            gx0, gy0, gx1,  gy1,
+            pysc.game['n_row'], pysc.game['n_col']
+        )       
+
+ss_view.when_game_start().add_handler(draw_selection_rect)