spacr 0.3.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

spacr/gui_elements.py

@@ -1,4 +1,4 @@
-import os, threading, time, sqlite3, webbrowser, pyautogui
+import os, threading, time, sqlite3, webbrowser, pyautogui, random, cv2
 import tkinter as tk
 from tkinter import ttk
 import tkinter.font as tkFont
@@ -7,7 +7,7 @@ from tkinter import font
 from queue import Queue
 from tkinter import Label, Frame, Button
 import numpy as np
-from PIL import Image, ImageOps, ImageTk
+from PIL import Image, ImageOps, ImageTk, ImageDraw, ImageFont, ImageEnhance
 from concurrent.futures import ThreadPoolExecutor
 from skimage.exposure import rescale_intensity
 from IPython.display import display, HTML
@@ -16,7 +16,8 @@ from collections import deque
 from skimage.draw import polygon, line
 from skimage.transform import resize
 from scipy.ndimage import binary_fill_holes, label
-from tkinter import ttk, scrolledtext
+from tkinter import ttk, scrolledtext 
+
 fig = None
 
 def set_element_size():
@@ -2512,7 +2513,6 @@ def create_menu_bar(root):
         "Annotate": lambda: initiate_root(root, settings_type='annotate'),
         "Make Masks": lambda: initiate_root(root, settings_type='make_masks'),
         "Classify": lambda: initiate_root(root, settings_type='classify'),
-        "Sequencing": lambda: initiate_root(root, settings_type='sequencing'),
         "Umap": lambda: initiate_root(root, settings_type='umap'),
         "Train Cellpose": lambda: initiate_root(root, settings_type='train_cellpose'),
         "ML Analyze": lambda: initiate_root(root, settings_type='ml_analyze'),
@@ -2842,4 +2842,109 @@ def modify_figure(fig):
 
     # Apply button
     apply_button = tk.Button(modify_window, text="Apply", command=apply_modifications, bg="#2E2E2E", fg="white")
-    apply_button.grid(row=len(options) + len(checkboxes), column=0, columnspan=2, pady=10)
+    apply_button.grid(row=len(options) + len(checkboxes), column=0, columnspan=2, pady=10)
+
+def generate_dna_matrix(output_path='dna_matrix.gif', canvas_width=1500, canvas_height=1000, duration=30, fps=20, base_size=20, transition_frames=30, font_type='arial.ttf', enhance=[1.1, 1.5, 1.2, 1.5], lowercase_prob=0.3):
+    """
+    Generate a DNA matrix animation and save it as GIF, MP4, or AVI using OpenCV for videos.
+    """
+
+    def save_output(frames, output_path, fps, output_format):
+        """Save the animation based on output format."""
+        if output_format in ['.mp4', '.avi']:
+            images = [np.array(img.convert('RGB')) for img in frames]
+            fourcc = cv2.VideoWriter_fourcc(*('mp4v' if output_format == '.mp4' else 'XVID'))
+            out = cv2.VideoWriter(output_path, fourcc, fps, (canvas_width, canvas_height))
+            for img in images:
+                out.write(cv2.cvtColor(img, cv2.COLOR_RGB2BGR))
+            out.release()
+        elif output_format == '.gif':
+            frames[0].save(output_path, save_all=True, append_images=frames[1:], duration=int(1000/fps), loop=0)
+
+    def draw_base(draw, col_idx, base_position, base, font, alpha=255, fill_color=None):
+        """Draws a DNA base at the specified position."""
+        draw.text((col_idx * base_size, base_position * base_size), base, fill=(*fill_color, alpha), font=font)
+
+    # Setup variables
+    num_frames = duration * fps
+    num_columns = canvas_width // base_size
+    bases = ['A', 'T', 'C', 'G']
+    active_color = (155, 55, 155)
+    color = (255, 255, 255)
+    base_colors = {'A': color, 'T': color, 'C': color, 'G': color}
+
+    _, output_format = os.path.splitext(output_path)
+    
+    # Initialize font
+    try:
+        font = ImageFont.truetype(font_type, base_size)
+    except IOError:
+        font = ImageFont.load_default()
+
+    # DNA string and positions
+    string_lengths = [random.randint(10, 100) for _ in range(num_columns)]
+    visible_bases = [0] * num_columns
+    base_positions = [random.randint(-canvas_height // base_size, 0) for _ in range(num_columns)]
+    column_strings = [[''] * 100 for _ in range(num_columns)]
+    random_white_sequences = [None] * num_columns
+
+    frames = []
+    end_frame_start = int(num_frames * 0.8)
+
+    for frame_idx in range(num_frames):
+        img = Image.new('RGBA', (canvas_width, canvas_height), color=(0, 0, 0, 255))
+        draw = ImageDraw.Draw(img)
+
+        for col_idx in range(num_columns):
+            if base_positions[col_idx] >= canvas_height // base_size and frame_idx < end_frame_start:
+                string_lengths[col_idx] = random.randint(10, 100)
+                base_positions[col_idx] = -string_lengths[col_idx]
+                visible_bases[col_idx] = 0
+                # Randomly choose whether to make each base lowercase
+                column_strings[col_idx] = [
+                    random.choice([base.lower(), base]) if random.random() < lowercase_prob else base
+                    for base in [random.choice(bases) for _ in range(string_lengths[col_idx])]
+                ]
+                if string_lengths[col_idx] > 8:
+                    random_start = random.randint(0, string_lengths[col_idx] - 8)
+                    random_white_sequences[col_idx] = range(random_start, random_start + 8)
+
+            last_10_percent_start = max(0, int(string_lengths[col_idx] * 0.9))
+            
+            for row_idx in range(min(visible_bases[col_idx], string_lengths[col_idx])):
+                base_position = base_positions[col_idx] + row_idx
+                if 0 <= base_position * base_size < canvas_height:
+                    base = column_strings[col_idx][row_idx]
+                    if base:
+                        if row_idx == visible_bases[col_idx] - 1:
+                            draw_base(draw, col_idx, base_position, base, font, fill_color=active_color)
+                        elif row_idx >= last_10_percent_start:
+                            alpha = 255 - int(((row_idx - last_10_percent_start) / (string_lengths[col_idx] - last_10_percent_start)) * 127)
+                            draw_base(draw, col_idx, base_position, base, font, alpha=alpha, fill_color=base_colors[base.upper()])
+                        elif random_white_sequences[col_idx] and row_idx in random_white_sequences[col_idx]:
+                            draw_base(draw, col_idx, base_position, base, font, fill_color=active_color)
+                        else:
+                            draw_base(draw, col_idx, base_position, base, font, fill_color=base_colors[base.upper()])
+
+            if visible_bases[col_idx] < string_lengths[col_idx]:
+                visible_bases[col_idx] += 1
+            base_positions[col_idx] += 2
+
+        # Convert the image to numpy array to check unique pixel values
+        img_array = np.array(img)
+        if len(np.unique(img_array)) > 2:  # Only append frames with more than two unique pixel values (avoid black frames)
+            # Enhance contrast and saturation
+            if enhance:
+                img = ImageEnhance.Brightness(img).enhance(enhance[0])   # Slightly increase brightness
+                img = ImageEnhance.Sharpness(img).enhance(enhance[1])    # Sharpen the image
+                img = ImageEnhance.Contrast(img).enhance(enhance[2])     # Enhance contrast
+                img = ImageEnhance.Color(img).enhance(enhance[3])        # Boost color saturation 
+
+            frames.append(img)
+
+    for i in range(transition_frames):
+        alpha = i / float(transition_frames)
+        transition_frame = Image.blend(frames[-1], frames[0], alpha)
+        frames.append(transition_frame)
+
+    save_output(frames, output_path, fps, output_format)

spacr/gui_utils.py

@@ -1,4 +1,4 @@
-import os, io, sys, ast, ctypes, ast, sqlite3, requests, time, traceback, torch
+import os, io, sys, ast, ctypes, ast, sqlite3, requests, time, traceback, torch, cv2
 import tkinter as tk
 from tkinter import ttk
 import matplotlib
@@ -6,6 +6,8 @@ import matplotlib.pyplot as plt
 matplotlib.use('Agg')
 from huggingface_hub import list_repo_files
 import psutil
+from PIL import Image, ImageTk
+from screeninfo import get_monitors
 
 from .gui_elements import AnnotateApp, spacrEntry, spacrCheck, spacrCombo
 
@@ -394,6 +396,7 @@ def convert_settings_dict_for_gui(settings):
         'train_channels': ('combo', ["['r','g','b']", "['r','g']", "['r','b']", "['g','b']", "['r']", "['g']", "['b']"], "['r','g','b']"),
         'channel_dims': ('combo', ['[0,1,2,3]', '[0,1,2]', '[0,1]', '[0]'], '[0,1,2,3]'),
         'dataset_mode': ('combo', ['annotation', 'metadata', 'recruitment'], 'metadata'),
+        'cov_type': ('combo', ['HC0', 'HC1', 'HC2', 'HC3', None], None),
         'cell_mask_dim': ('combo', chans, None),
         'cell_chann_dim': ('combo', chans, None),
         'nucleus_mask_dim': ('combo', chans, None),
@@ -486,12 +489,16 @@ def function_gui_wrapper(function=None, settings={}, q=None, fig_queue=None, imp
 def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
     
     from .gui_utils import process_stdout_stderr
-    from .core import generate_image_umap, preprocess_generate_masks, generate_ml_scores, identify_masks_finetune, check_cellpose_models, analyze_recruitment, train_cellpose, analyze_plaques, compare_cellpose_masks, generate_dataset, apply_model_to_tar
-    from .io import generate_cellpose_train_test
+    from .core import generate_image_umap, preprocess_generate_masks
+    from .cellpose import identify_masks_finetune, check_cellpose_models, compare_cellpose_masks
+    from .submodules import analyze_recruitment
+    from .ml import generate_ml_scores, perform_regression
+    from .submodules import train_cellpose, analyze_plaques
+    from .io import process_non_tif_non_2D_images, generate_cellpose_train_test, generate_dataset
     from .measure import measure_crop
     from .sim import run_multiple_simulations
-    from .deep_spacr import deep_spacr
-    from .sequencing import generate_barecode_mapping, perform_regression
+    from .deep_spacr import deep_spacr, apply_model_to_tar
+    from .sequencing import generate_barecode_mapping
     process_stdout_stderr(q)
 
     print(f'run_function_gui settings_type: {settings_type}') 
@@ -535,6 +542,9 @@ def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
     elif settings_type == 'analyze_plaques':
         function = analyze_plaques
         imports = 1
+    elif settings_type == 'convert':
+        function = process_non_tif_non_2D_images
+        imports = 1
     else:
         raise ValueError(f"Invalid settings type: {settings_type}")
     try:
@@ -697,4 +707,334 @@ def download_dataset(q, repo_id, subfolder, local_dir=None, retries=5, delay=5):
 
 def ensure_after_tasks(frame):
     if not hasattr(frame, 'after_tasks'):
-        frame.after_tasks = []
+        frame.after_tasks = []
+
+def display_gif_in_plot_frame_v1(gif_path, parent_frame):
+    """Display and zoom a GIF to fill the entire parent_frame, maintaining aspect ratio, with lazy resizing and caching."""
+    # Clear parent_frame if it contains any previous widgets
+    for widget in parent_frame.winfo_children():
+        widget.destroy()
+
+    # Load the GIF
+    gif = Image.open(gif_path)
+
+    # Get the aspect ratio of the GIF
+    gif_width, gif_height = gif.size
+    gif_aspect_ratio = gif_width / gif_height
+
+    # Create a label to display the GIF and configure it to fill the parent_frame
+    label = tk.Label(parent_frame, bg="black")
+    label.grid(row=0, column=0, sticky="nsew")  # Expands in all directions (north, south, east, west)
+
+    # Configure parent_frame to stretch the label to fill available space
+    parent_frame.grid_rowconfigure(0, weight=1)
+    parent_frame.grid_columnconfigure(0, weight=1)
+
+    # Cache for storing resized frames (lazily filled)
+    resized_frames_cache = {}
+
+    # Last frame dimensions
+    last_frame_width = 0
+    last_frame_height = 0
+
+    def resize_and_crop_frame(frame_idx, frame_width, frame_height):
+        """Resize and crop the current frame of the GIF to fit the parent_frame while maintaining the aspect ratio."""
+        # If the frame is already cached at the current size, return it
+        if (frame_idx, frame_width, frame_height) in resized_frames_cache:
+            return resized_frames_cache[(frame_idx, frame_width, frame_height)]
+
+        # Calculate the scaling factor to zoom in on the GIF
+        scale_factor = max(frame_width / gif_width, frame_height / gif_height)
+
+        # Calculate new dimensions while maintaining the aspect ratio
+        new_width = int(gif_width * scale_factor)
+        new_height = int(gif_height * scale_factor)
+
+        # Resize the GIF to fit the frame
+        gif.seek(frame_idx)
+        resized_gif = gif.copy().resize((new_width, new_height), Image.Resampling.LANCZOS)
+
+        # Calculate the cropping box to center the resized GIF in the frame
+        crop_left = (new_width - frame_width) // 2
+        crop_top = (new_height - frame_height) // 2
+        crop_right = crop_left + frame_width
+        crop_bottom = crop_top + frame_height
+
+        # Crop the resized GIF to exactly fit the frame
+        cropped_gif = resized_gif.crop((crop_left, crop_top, crop_right, crop_bottom))
+
+        # Convert the cropped frame to a Tkinter-compatible format
+        frame_image = ImageTk.PhotoImage(cropped_gif)
+
+        # Cache the resized frame
+        resized_frames_cache[(frame_idx, frame_width, frame_height)] = frame_image
+
+        return frame_image
+
+    def update_frame(frame_idx):
+        """Update the GIF frame using lazy resizing and caching."""
+        # Get the current size of the parent_frame
+        frame_width = parent_frame.winfo_width()
+        frame_height = parent_frame.winfo_height()
+
+        # Only resize if the frame size has changed
+        nonlocal last_frame_width, last_frame_height
+        if frame_width != last_frame_width or frame_height != last_frame_height:
+            last_frame_width, last_frame_height = frame_width, frame_height
+
+        # Get the resized and cropped frame image
+        frame_image = resize_and_crop_frame(frame_idx, frame_width, frame_height)
+        label.config(image=frame_image)
+        label.image = frame_image  # Keep a reference to avoid garbage collection
+
+        # Move to the next frame, or loop back to the beginning
+        next_frame_idx = (frame_idx + 1) % gif.n_frames
+        parent_frame.after(gif.info['duration'], update_frame, next_frame_idx)
+
+    # Start the GIF animation from frame 0
+    update_frame(0)
+
+def display_gif_in_plot_frame(gif_path, parent_frame):
+    """Display and zoom a GIF to fill the entire parent_frame, maintaining aspect ratio, with lazy resizing and caching."""
+    # Clear parent_frame if it contains any previous widgets
+    for widget in parent_frame.winfo_children():
+        widget.destroy()
+
+    # Load the GIF
+    gif = Image.open(gif_path)
+
+    # Get the aspect ratio of the GIF
+    gif_width, gif_height = gif.size
+    gif_aspect_ratio = gif_width / gif_height
+
+    # Create a label to display the GIF and configure it to fill the parent_frame
+    label = tk.Label(parent_frame, bg="black")
+    label.grid(row=0, column=0, sticky="nsew")  # Expands in all directions (north, south, east, west)
+
+    # Configure parent_frame to stretch the label to fill available space
+    parent_frame.grid_rowconfigure(0, weight=1)
+    parent_frame.grid_columnconfigure(0, weight=1)
+
+    # Cache for storing resized frames (lazily filled)
+    resized_frames_cache = {}
+
+    # Store last frame size and aspect ratio
+    last_frame_width = 0
+    last_frame_height = 0
+
+    def resize_and_crop_frame(frame_idx, frame_width, frame_height):
+        """Resize and crop the current frame of the GIF to fit the parent_frame while maintaining the aspect ratio."""
+        # If the frame is already cached at the current size, return it
+        if (frame_idx, frame_width, frame_height) in resized_frames_cache:
+            return resized_frames_cache[(frame_idx, frame_width, frame_height)]
+
+        # Calculate the scaling factor to zoom in on the GIF
+        scale_factor = max(frame_width / gif_width, frame_height / gif_height)
+
+        # Calculate new dimensions while maintaining the aspect ratio
+        new_width = int(gif_width * scale_factor)
+        new_height = int(gif_height * scale_factor)
+
+        # Resize the GIF to fit the frame using NEAREST for faster resizing
+        gif.seek(frame_idx)
+        resized_gif = gif.copy().resize((new_width, new_height), Image.Resampling.NEAREST if scale_factor > 2 else Image.Resampling.LANCZOS)
+
+        # Calculate the cropping box to center the resized GIF in the frame
+        crop_left = (new_width - frame_width) // 2
+        crop_top = (new_height - frame_height) // 2
+        crop_right = crop_left + frame_width
+        crop_bottom = crop_top + frame_height
+
+        # Crop the resized GIF to exactly fit the frame
+        cropped_gif = resized_gif.crop((crop_left, crop_top, crop_right, crop_bottom))
+
+        # Convert the cropped frame to a Tkinter-compatible format
+        frame_image = ImageTk.PhotoImage(cropped_gif)
+
+        # Cache the resized frame
+        resized_frames_cache[(frame_idx, frame_width, frame_height)] = frame_image
+
+        return frame_image
+
+    def update_frame(frame_idx):
+        """Update the GIF frame using lazy resizing and caching."""
+        # Get the current size of the parent_frame
+        frame_width = parent_frame.winfo_width()
+        frame_height = parent_frame.winfo_height()
+
+        # Only resize if the frame size has changed
+        nonlocal last_frame_width, last_frame_height
+        if frame_width != last_frame_width or frame_height != last_frame_height:
+            last_frame_width, last_frame_height = frame_width, frame_height
+
+        # Get the resized and cropped frame image
+        frame_image = resize_and_crop_frame(frame_idx, frame_width, frame_height)
+        label.config(image=frame_image)
+        label.image = frame_image  # Keep a reference to avoid garbage collection
+
+        # Move to the next frame, or loop back to the beginning
+        next_frame_idx = (frame_idx + 1) % gif.n_frames
+        parent_frame.after(gif.info['duration'], update_frame, next_frame_idx)
+
+    # Start the GIF animation from frame 0
+    update_frame(0)
+    
+def display_media_in_plot_frame(media_path, parent_frame):
+    """Display an MP4, AVI, or GIF and play it on repeat in the parent_frame, fully filling the frame while maintaining aspect ratio."""
+    # Clear parent_frame if it contains any previous widgets
+    for widget in parent_frame.winfo_children():
+        widget.destroy()
+
+    # Check file extension to decide between video (mp4/avi) or gif
+    file_extension = os.path.splitext(media_path)[1].lower()
+
+    if file_extension in ['.mp4', '.avi']:
+        # Handle video formats (mp4, avi) using OpenCV
+        video = cv2.VideoCapture(media_path)
+
+        # Create a label to display the video
+        label = tk.Label(parent_frame, bg="black")
+        label.grid(row=0, column=0, sticky="nsew")
+
+        # Configure the parent_frame to expand
+        parent_frame.grid_rowconfigure(0, weight=1)
+        parent_frame.grid_columnconfigure(0, weight=1)
+
+        def update_frame():
+            """Update function for playing video."""
+            ret, frame = video.read()
+            if ret:
+                # Get the frame dimensions
+                frame_height, frame_width, _ = frame.shape
+
+                # Get parent frame dimensions
+                parent_width = parent_frame.winfo_width()
+                parent_height = parent_frame.winfo_height()
+
+                # Ensure dimensions are greater than 0
+                if parent_width > 0 and parent_height > 0:
+                    # Calculate the aspect ratio of the media
+                    frame_aspect_ratio = frame_width / frame_height
+                    parent_aspect_ratio = parent_width / parent_height
+
+                    # Determine whether to scale based on width or height to cover the parent frame
+                    if parent_aspect_ratio > frame_aspect_ratio:
+                        # The parent frame is wider than the video aspect ratio
+                        # Fit to width, crop height
+                        new_width = parent_width
+                        new_height = int(parent_width / frame_aspect_ratio)
+                    else:
+                        # The parent frame is taller than the video aspect ratio
+                        # Fit to height, crop width
+                        new_width = int(parent_height * frame_aspect_ratio)
+                        new_height = parent_height
+
+                    # Resize the frame to the new dimensions (cover the parent frame)
+                    resized_frame = cv2.resize(frame, (new_width, new_height))
+
+                    # Crop the frame to fit exactly within the parent frame
+                    x_offset = (new_width - parent_width) // 2
+                    y_offset = (new_height - parent_height) // 2
+                    cropped_frame = resized_frame[y_offset:y_offset + parent_height, x_offset:x_offset + parent_width]
+
+                    # Convert the frame to RGB (OpenCV uses BGR by default)
+                    cropped_frame = cv2.cvtColor(cropped_frame, cv2.COLOR_BGR2RGB)
+
+                    # Convert the frame to a Tkinter-compatible format
+                    frame_image = ImageTk.PhotoImage(Image.fromarray(cropped_frame))
+
+                    # Update the label with the new frame
+                    label.config(image=frame_image)
+                    label.image = frame_image  # Keep a reference to avoid garbage collection
+
+                # Call update_frame again after a delay to match the video's frame rate
+                parent_frame.after(int(1000 / video.get(cv2.CAP_PROP_FPS)), update_frame)
+            else:
+                # Restart the video if it reaches the end
+                video.set(cv2.CAP_PROP_POS_FRAMES, 0)
+                update_frame()
+
+        # Start the video playback
+        update_frame()
+
+    elif file_extension == '.gif':
+        # Handle GIF format using PIL
+        gif = Image.open(media_path)
+
+        # Create a label to display the GIF
+        label = tk.Label(parent_frame, bg="black")
+        label.grid(row=0, column=0, sticky="nsew")
+
+        # Configure the parent_frame to expand
+        parent_frame.grid_rowconfigure(0, weight=1)
+        parent_frame.grid_columnconfigure(0, weight=1)
+
+        def update_gif_frame(frame_idx):
+            """Update function for playing GIF."""
+            try:
+                gif.seek(frame_idx)  # Move to the next frame
+
+                # Get the frame dimensions
+                gif_width, gif_height = gif.size
+
+                # Get parent frame dimensions
+                parent_width = parent_frame.winfo_width()
+                parent_height = parent_frame.winfo_height()
+
+                # Ensure dimensions are greater than 0
+                if parent_width > 0 and parent_height > 0:
+                    # Calculate the aspect ratio of the GIF
+                    gif_aspect_ratio = gif_width / gif_height
+                    parent_aspect_ratio = parent_width / parent_height
+
+                    # Determine whether to scale based on width or height to cover the parent frame
+                    if parent_aspect_ratio > gif_aspect_ratio:
+                        # Fit to width, crop height
+                        new_width = parent_width
+                        new_height = int(parent_width / gif_aspect_ratio)
+                    else:
+                        # Fit to height, crop width
+                        new_width = int(parent_height * gif_aspect_ratio)
+                        new_height = parent_height
+
+                    # Resize the GIF frame to cover the parent frame
+                    resized_gif = gif.copy().resize((new_width, new_height), Image.Resampling.LANCZOS)
+
+                    # Crop the resized GIF to fit the exact parent frame dimensions
+                    x_offset = (new_width - parent_width) // 2
+                    y_offset = (new_height - parent_height) // 2
+                    cropped_gif = resized_gif.crop((x_offset, y_offset, x_offset + parent_width, y_offset + parent_height))
+
+                    # Convert the frame to a Tkinter-compatible format
+                    frame_image = ImageTk.PhotoImage(cropped_gif)
+
+                    # Update the label with the new frame
+                    label.config(image=frame_image)
+                    label.image = frame_image  # Keep a reference to avoid garbage collection
+                    frame_idx += 1
+            except EOFError:
+                frame_idx = 0  # Restart the GIF if at the end
+
+            # Schedule the next frame update
+            parent_frame.after(gif.info['duration'], update_gif_frame, frame_idx)
+
+        # Start the GIF animation from frame 0
+        update_gif_frame(0)
+
+    else:
+        raise ValueError("Unsupported file format. Only .mp4, .avi, and .gif are supported.")
+
+def print_widget_structure(widget, indent=0):
+    """Recursively print the widget structure."""
+    # Print the widget's name and class
+    print(" " * indent + f"{widget}: {widget.winfo_class()}")
+    
+    # Recursively print all child widgets
+    for child_name, child_widget in widget.children.items():
+        print_widget_structure(child_widget, indent + 2)
+
+def get_screen_dimensions():
+    monitor = get_monitors()[0]  # Get the primary monitor
+    screen_width = monitor.width
+    screen_height = monitor.height
+    return screen_width, screen_height