py2ls 0.1.9.9__py3-none-any.whl → 0.1.10.0__py3-none-any.whl

py2ls/batman.py

@@ -0,0 +1,183 @@
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from email.mime.base import MIMEBase
+from email import encoders
+import schedule
+import time
+from datetime import datetime
+import os
+
+
+signature_styles = [
+    "",  # none
+    (
+        "------------------------------------------------------------------------------------------------\n"
+        "Jianfeng Liu, PhD\n"
+        "Institute of Medical Psychology and Behavioural Neurobiology\n"
+        "University of Tübingen\n"
+        "Otfried-Müller-Str. 25\n"
+        "72076 Tübingen\n\n"
+    ),
+    f"Pappelweg 8\n72076 Tübingen\n\n",
+]
+
+
+def email_to(**kwargs):
+    """
+    usage:
+    email_to(who="example@gmail.com",
+            subject="test",
+            what="this is the body",
+            attachments="/Users/test.pdf")
+    Send an email with optional attachments.
+
+    :param who: Recipient email address
+    :param subject: Email subject
+    :param what: Email what
+    :param attachments: List of file paths to attach
+    """
+    who, what, subject = None, None, None
+    attachments = False
+    pause_sec = False  # default 10 seconds pause
+    signature = signature_styles[0]
+
+    # params config
+    for k, v in kwargs.items():
+        if any(
+            [
+                "who" in k.lower(),
+                "whe" in k.lower(),
+                all(["@" in k.lower(), "." in k.lower()]),
+            ]
+        ):  # 'who' or "where"
+            who = v
+        if any(["sub" in k.lower(), "hea" in k.lower()]):  # 'subject', 'header'
+            subject = v
+        if any(
+            ["wha" in k.lower(), "con" in k.lower(), "bod" in k.lower()]
+        ):  # 'what','content','body'
+            what = v
+        if any(["att" in k.lower(), "fil" in k.lower()]):  # 'attachments', 'file'
+            attachments = v  # optional
+        if any(
+            ["paus" in k.lower(), "tim" in k.lower(), "delay" in k.lower()]
+        ):  # 'attachments', 'file'
+            pause_sec = v  # optional
+        if any(["sig" in k.lower()]):  # 'attachments', 'file'
+            signature = v  # optional
+            if not isinstance(v, str):
+                signature = signature_styles[v]
+
+    # config sender
+    email_address = "andyandhope@gmail.com"
+    email_password = "myff ltls sfym wehe"  # this is fake info
+
+    # Create email message
+    message = MIMEMultipart()
+    message["From"] = email_address
+    message["To"] = who
+    message["Subject"] = subject
+
+    # add signature
+    if signature:
+        what += f"\n\n{signature}\n"
+
+    # the eamil's body
+    message.attach(MIMEText(what, "plain"))
+
+    # attach files
+    if attachments:
+        if isinstance(attachments, str):
+            attachments = [attachments]
+        for file in attachments:
+            part = MIMEBase("application", "octet-stream")
+            try:
+                with open(file, "rb") as attachment:
+                    part.set_payload(attachment.read())
+                encoders.encode_base64(part)
+
+                fname = os.path.basename(file)
+                print(fname)
+                part.add_header(
+                    "Content-Disposition", f'attachment; filename= "{fname}"'
+                )
+                message.attach(part)
+            except FileNotFoundError:
+                print(f"File not found: {file}")
+            except Exception as e:
+                print(f"Error attaching file {file}: {e}")
+    if pause_sec:
+        time.sleep(pause_sec)
+    # Send the email
+    try:
+        with smtplib.SMTP("smtp.gmail.com", 587) as server:
+            server.starttls()
+            server.login(email_address, email_password)
+            server.sendmail(email_address, who, message.as_string())
+        print(f"Email successfully sent to {who}")
+    except Exception as e:
+        print(f"Failed to send email: {e}")
+
+
+def email_to_every(who, subject, what, when, attachments=None):
+    """
+    Check the time and send an email when the time matches the when.
+
+    :param who: Recipient email address
+    :param subject: Email subject
+    :param what: Email what
+    :param when: Time to send the email in HH:MM format
+    :param attachments: List of file paths to attach
+    """
+    current_time = datetime.now().strftime("%H:%M")
+    if current_time == when:
+        email_to(
+            who=who,
+            subject=subject,
+            what=what,
+            attachments=attachments,
+        )
+
+
+# Example usage
+def example_job():
+    # Example email details
+    reminder_subject = "Reminder: Important Meeting Tomorrow"
+    reminder_what = (
+        "Don't forget about the meeting tomorrow at 10 AM in the conference room."
+    )
+    who = "Jianfeng.Liu0413@gmail.com"
+    when = "14:30"  # Send time in 24-hour format
+
+    # Optional attachments
+    attachments = ["path/to/attachment1.pdf", "path/to/attachment2.jpg"]
+
+    # Schedule the email
+    email_to_every(who, reminder_subject, reminder_what, when, attachments)
+
+
+if __name__ == "__main__":
+    # Schedule the job to run every minute
+    schedule.every(1).minutes.do(example_job)
+
+    while True:
+        schedule.run_pending()
+        time.sleep(1)
+
+    # example2:
+    email_to(
+        who="Jianfeng.Liu@medizin.uni-tuebingen.de",
+        subj="test",
+        wha="this is the body",
+        signat="\n\n Best, Jianfeng\n",
+        att="/Users/macjianfeng/Dropbox/Downloads/_*_doc-xlsx/20240822-preprints_full_20190101_20201031-2.xlsx",
+    )
+    # example3:
+    email_to(
+        who="Jianfeng.Liu@medizin.uni-tuebingen.de",
+        subj="test",
+        wha="this is the test",
+        signat=2,
+        att="/Users/macjianfeng/Dropbox/Downloads/_*_doc-xlsx/20240822-preprints_full_20190101_20201031-2.xlsx",
+    )

py2ls/ich2ls.py

@@ -1,103 +1,212 @@
 import numpy as np
+import pandas as pd
 import matplotlib.pyplot as plt
 from scipy.stats import pearsonr
 from PIL import Image
 from skimage import filters, morphology, measure, color
 
+#  用来处理ich图像的初级工具包
 
-def img_preprocess(dir_img, subtract_background=True, size_obj=50, size_hole=50):
-    """
-    Processes an image by performing thresholding, morphological operations,
-    and region labeling.
 
-    Parameters:
-    - dir_img: Path to the image file.
-    - size_obj: Minimum size of objects to keep (default: 50).
-    - size_hole: Maximum size of holes to fill (default: 50).
+def open_img(dir_img, convert="gray", plot=False):
+    # Step 1: Load the image
+    image = Image.open(dir_img)
 
-    Returns:
-    - output: Dictionary containing the overlay image, threshold value, and regions.
-    """
-    props_list = [
-        "area",  # Number of pixels in the region. Useful for determining the size of regions.
-        "area_bbox",
-        "area_convex",
-        "area_filled",
-        "axis_major_length",  # Lengths of the major and minor axes of the ellipse that fits the region. Useful for understanding the shape's elongation and orientation.
-        "axis_minor_length",
-        "bbox",  # Bounding box coordinates (min_row, min_col, max_row, max_col). Useful for spatial localization of regions.
-        "centroid",  # Center of mass coordinates (centroid-0, centroid-1). Helps locate the center of each region.
-        "centroid_local",
-        "centroid_weighted",
-        "centroid_weighted_local",
-        "coords",
-        "eccentricity",  # Measure of how elongated the region is. Values range from 0 (circular) to 1 (line). Useful for assessing the shape of regions.
-        "equivalent_diameter_area",  # Diameter of a circle with the same area as the region. Provides a simple measure of size.
-        "euler_number",
-        "extent",  # Ratio of the region's area to the area of its bounding box. Indicates how much of the bounding box is filled by the region.
-        "feret_diameter_max",  # Maximum diameter of the region, providing another measure of size.
-        "image",
-        "image_convex",
-        "image_filled",
-        "image_intensity",
-        "inertia_tensor",  # ensor describing the distribution of mass in the region, useful for more advanced shape analysis.
-        "inertia_tensor_eigvals",
-        "intensity_max",  # Maximum intensity value within the region. Helps identify regions with high-intensity features.
-        "intensity_mean",  # Average intensity value within the region. Useful for distinguishing between regions based on their brightness.
-        "intensity_min",  # Minimum intensity value within the region. Useful for regions with varying intensity.
-        "intensity_std",
-        "label",  # Unique identifier for each region.
-        "moments",
-        "moments_central",
-        "moments_hu",  # Hu moments are a set of seven invariant features that describe the shape of the region. Useful for shape recognition and classification.
-        "moments_normalized",
-        "moments_weighted",
-        "moments_weighted_central",
-        "moments_weighted_hu",
-        "moments_weighted_normalized",
-        "orientation",  # ngle of the major axis of the ellipse that fits the region. Useful for determining the orientation of elongated regions.
-        "perimeter",  # Length of the boundary of the region. Useful for shape analysis.
-        "perimeter_crofton",
-        "slice",
-        "solidity",  # Ratio of the area of the region to the area of its convex hull. Indicates how solid or compact a region is.
-    ]
-    if isinstance(dir_img, str):
-        # Step 1: Load the image
-        image = Image.open(dir_img)
-
-        # Step 2: Convert the image to grayscale and normalize
+    if convert == "gray" or convert == "grey":
         gray_image = image.convert("L")
         image_array = np.array(gray_image)
+    else:
+        image_array = np.array(image)
+    if plot:
+        _, axs = plt.subplots(1, 2)
+        axs[0].imshow(image)
+        axs[1].imshow(image_array)
+        axs[0].set_title("img_raw")
+        axs[1].set_title(f"img_{convert}")
+    return image, image_array
+
+
+from skimage import filters, morphology
+
+
+def clean_img(
+    img,
+    method=["threshold_otsu", "objects", "holes"],
+    obj_min=50,
+    hole_min=50,
+    filter=None,
+    plot=False,
+    cmap="grey",
+):
+    if isinstance(method, str):
+        if method == "all":
+            method = ["threshold_otsu", "objects", "holes"]
+        else:
+            method = [method]
+    if any("thr" in met or "ot" in met for met in method) and filter is None:
+        thr_otsu = filters.threshold_otsu(img)
+        img_update = img > thr_otsu
+    if any("obj" in met for met in method):
+        img_update = morphology.remove_small_objects(img_update, min_size=obj_min)
+    if any("hol" in met for met in method):
+        img_update = morphology.remove_small_holes(img_update, area_threshold=hole_min)
+    if ("thr" in met for met in method) and filter:  # threshold
+        mask = (img >= filter[0]) & (img <= filter[1])
+        img_update = np.where(mask, img, 0)
+
+    if plot:
+        plt.imshow(img_update, cmap=cmap)
+    return img_update
+
+
+from skimage import filters, segmentation
+
+
+def segment_img(
+    img,
+    filter=[30, 150],
+    plot=False,
+    mode="reflect",  # 'reflect' or 'constant'
+    method="region",  # 'region' or 'edge', 'threshold'
+    area_min=50,
+    cmap="jet",
+    connectivity=1,
+    output="segmentation",
+):
+    if "reg" in method:  # region method
+        # 1. find an elevation map using the Sobel gradient of the image
+        elevation_map = filters.sobel(img, mode=mode)
+        # 2. find markers of the background and the coins based on the extreme parts of the histogram of gray values.
+        markers = np.zeros_like(img)
+        # Apply filtering based on provided filter values
+        if filter is not None:
+            markers[img < filter[0]] = 1
+            markers[img > filter[1]] = 2
+        else:
+            # If no filter is provided, set markers across the whole range of the image
+            markers[img == img.min()] = 1
+            markers[img == img.max()] = 2
+        # 3. watershed transform to fill regions of the elevation map starting from the markers
+        img_segmentation = segmentation.watershed(
+            elevation_map, markers=markers, connectivity=connectivity
+        )
+        if plot:
+            _, axs = plt.subplots(2, 2)
+            for i, ax in enumerate(axs.flatten().tolist()):
+                if i == 0:
+                    ax.imshow(img)
+                    ax.set_title("image")
+                elif i == 1:
+                    ax.imshow(elevation_map, cmap=cmap)
+                    ax.set_title("elevation map")
+                elif i == 2:
+                    ax.imshow(markers, cmap=cmap)
+                    ax.set_title("markers")
+                elif i == 3:
+                    ax.imshow(img_segmentation, cmap=cmap)
+                    ax.set_title("segmentation")
+                ax.set_axis_off()
+        if "el" in output:
+            return elevation_map
+        elif "mar" in output:
+            return markers
+        elif "seg" in output:
+            return img_segmentation
+        else:
+            return img_segmentation
+    elif "ed" in method:  # edge
+        edges = cal_edges(img)
+        fills = fill_holes(edges)
+        img_segmentation = remove_holes(fills, area_min)
+        if plot:
+            _, axs = plt.subplots(2, 2)
+            for i, ax in enumerate(axs.flatten().tolist()):
+                if i == 0:
+                    ax.imshow(img)
+                    ax.set_title("image")
+                elif i == 1:
+                    ax.imshow(edges, cmap=cmap)
+                    ax.set_title("edges map")
+                elif i == 2:
+                    ax.imshow(fills, cmap=cmap)
+                    ax.set_title("fills")
+                elif i == 3:
+                    ax.imshow(img_segmentation, cmap=cmap)
+                    ax.set_title("segmentation")
+                ax.set_axis_off()
+        if "seg" in output:
+            return img_segmentation
+        elif "ed" in output:
+            return edges
+        elif "fill" in output:
+            return fills
+        else:
+            return img_segmentation
+    elif "thr" in method:  # threshold
+        if filter:
+            mask = (img >= filter[0]) & (img <= filter[1])
+            img_threshold = np.where(mask, img, 0)
+            if plot:
+                plt.imshow(img_threshold, cmap=cmap)
+            return img_threshold
+        else:
+            return None
+
+
+from skimage import measure
+
+
+def label_img(img, plot=False):
+    img_label = measure.label(img)
+    if plot:
+        plt.imshow(img_label)
+    return img_label
+
+
+def img_process(img, **kwargs):
+    convert = "gray"
+    method_clean_img = ["threshold_otsu", "objects", "holes"]
+    obj_min_clean_img = 50
+    hole_min_clean_img = 50
+    plot = True
+    for k, v in kwargs.items():
+        if "convert" in k.lower():
+            convert = v
+        if "met" in k.lower() and any(
+            ["clean" in k.lower(), "rem" in k.lower(), "rm" in k.lower()]
+        ):
+            method_clean_img = v
+        if "obj" in k.lower() and any(
+            ["clean" in k.lower(), "rem" in k.lower(), "rm" in k.lower()]
+        ):
+            obj_min_clean_img = v
+        if "hol" in k.lower() and any(
+            ["clean" in k.lower(), "rem" in k.lower(), "rm" in k.lower()]
+        ):
+            hole_min_clean_img = v
+        if "plot" in k.lower():
+            plot = v
+
+    if isinstance(img, str):
+        image, image_array = open_img(img, convert=convert)
         normalized_image = image_array / 255.0
     else:
-        cleaned_image = dir_img
+        cleaned_image = img
         image_array = cleaned_image
         normalized_image = cleaned_image
         image = cleaned_image
-        binary_image = cleaned_image
-        thr_val = None
-    if subtract_background:
-        # Step 3: Apply thresholding to segment the image
-        thr_val = filters.threshold_otsu(image_array)
-        print(f"Threshold value is: {thr_val}")
-
-        # Apply thresholds and generate binary images
-        binary_image = image_array > thr_val
-
-        # Step 4: Perform morphological operations to clean the image
-        # Remove small objects and fill small holes
-        cleaned_image_rm_min_obj = morphology.remove_small_objects(
-            binary_image, min_size=size_obj
-        )
-        cleaned_image = morphology.remove_small_holes(
-            cleaned_image_rm_min_obj, area_threshold=size_hole
-        )
 
+    # Remove small objects and fill small holes
+    cleaned_image = clean_img(
+        img=image_array,
+        method=method_clean_img,
+        obj_min=obj_min_clean_img,
+        hole_min=hole_min_clean_img,
+        plot=False,
+    )
     # Label the regions
-    label_image = measure.label(cleaned_image)
-
-    # Optional: Overlay labels on the original image
-    overlay_image = color.label2rgb(label_image, image_array)
+    label_image = label_img(cleaned_image)
+    overlay_image = overlay_imgs(label_image, image=image_array)
     regions = measure.regionprops(label_image, intensity_image=image_array)
     region_props = measure.regionprops_table(
         label_image, intensity_image=image_array, properties=props_list
@@ -108,18 +217,137 @@ def img_preprocess(dir_img, subtract_background=True, size_obj=50, size_hole=50)
         "img": image,
         "img_array": image_array,
         "img_scale": normalized_image,
-        "img_binary": binary_image,
         "img_clean": cleaned_image,
         "img_label": label_image,
         "img_overlay": overlay_image,
-        "thr_val": thr_val,
         "regions": regions,
         "df_regions": df_regions,
     }
-
+    if plot:
+        imgs = []
+        [imgs.append(i) for i in list(output.keys()) if "img" in i]
+        for img_ in imgs:
+            plt.figure()
+            plt.imshow(output[img_])
+            plt.title(img_)
     return output
 
 
+# def img_preprocess(dir_img, subtract_background=True, size_obj=50, size_hole=50,**kwargs):
+#     """
+#     Processes an image by performing thresholding, morphological operations,
+#     and region labeling.
+
+#     Parameters:
+#     - dir_img: Path to the image file.
+#     - size_obj: Minimum size of objects to keep (default: 50).
+#     - size_hole: Maximum size of holes to fill (default: 50).
+
+#     Returns:
+#     - output: Dictionary containing the overlay image, threshold value, and regions.
+#     """
+#     props_list = [
+#         "area",  # Number of pixels in the region. Useful for determining the size of regions.
+#         "area_bbox",
+#         "area_convex",
+#         "area_filled",
+#         "axis_major_length",  # Lengths of the major and minor axes of the ellipse that fits the region. Useful for understanding the shape's elongation and orientation.
+#         "axis_minor_length",
+#         "bbox",  # Bounding box coordinates (min_row, min_col, max_row, max_col). Useful for spatial localization of regions.
+#         "centroid",  # Center of mass coordinates (centroid-0, centroid-1). Helps locate the center of each region.
+#         "centroid_local",
+#         "centroid_weighted",
+#         "centroid_weighted_local",
+#         "coords",
+#         "eccentricity",  # Measure of how elongated the region is. Values range from 0 (circular) to 1 (line). Useful for assessing the shape of regions.
+#         "equivalent_diameter_area",  # Diameter of a circle with the same area as the region. Provides a simple measure of size.
+#         "euler_number",
+#         "extent",  # Ratio of the region's area to the area of its bounding box. Indicates how much of the bounding box is filled by the region.
+#         "feret_diameter_max",  # Maximum diameter of the region, providing another measure of size.
+#         "image",
+#         "image_convex",
+#         "image_filled",
+#         "image_intensity",
+#         "inertia_tensor",  # ensor describing the distribution of mass in the region, useful for more advanced shape analysis.
+#         "inertia_tensor_eigvals",
+#         "intensity_max",  # Maximum intensity value within the region. Helps identify regions with high-intensity features.
+#         "intensity_mean",  # Average intensity value within the region. Useful for distinguishing between regions based on their brightness.
+#         "intensity_min",  # Minimum intensity value within the region. Useful for regions with varying intensity.
+#         "intensity_std",
+#         "label",  # Unique identifier for each region.
+#         "moments",
+#         "moments_central",
+#         "moments_hu",  # Hu moments are a set of seven invariant features that describe the shape of the region. Useful for shape recognition and classification.
+#         "moments_normalized",
+#         "moments_weighted",
+#         "moments_weighted_central",
+#         "moments_weighted_hu",
+#         "moments_weighted_normalized",
+#         "orientation",  # ngle of the major axis of the ellipse that fits the region. Useful for determining the orientation of elongated regions.
+#         "perimeter",  # Length of the boundary of the region. Useful for shape analysis.
+#         "perimeter_crofton",
+#         "slice",
+#         "solidity",  # Ratio of the area of the region to the area of its convex hull. Indicates how solid or compact a region is.
+#     ]
+#     if isinstance(dir_img, str):
+#         # Step 1: Load the image
+#         image = Image.open(dir_img)
+
+#         # Step 2: Convert the image to grayscale and normalize
+#         gray_image = image.convert("L")
+#         image_array = np.array(gray_image)
+#         normalized_image = image_array / 255.0
+#     else:
+#         cleaned_image = dir_img
+#         image_array = cleaned_image
+#         normalized_image = cleaned_image
+#         image = cleaned_image
+#         binary_image = cleaned_image
+#         thr_val = None
+#     if subtract_background:
+#         # Step 3: Apply thresholding to segment the image
+#         thr_val = filters.threshold_otsu(image_array)
+#         print(f"Threshold value is: {thr_val}")
+
+#         # Apply thresholds and generate binary images
+#         binary_image = image_array > thr_val
+
+#         # Step 4: Perform morphological operations to clean the image
+#         # Remove small objects and fill small holes
+#         cleaned_image_rm_min_obj = morphology.remove_small_objects(
+#             binary_image, min_size=size_obj
+#         )
+#         cleaned_image = morphology.remove_small_holes(
+#             cleaned_image_rm_min_obj, area_threshold=size_hole
+#         )
+
+#     # Label the regions
+#     label_image = label_img(cleaned_image)
+
+#     # Optional: Overlay labels on the original image
+#     overlay_image = color.label2rgb(label_image, image_array)
+#     regions = measure.regionprops(label_image, intensity_image=image_array)
+#     region_props = measure.regionprops_table(
+#         label_image, intensity_image=image_array, properties=props_list
+#     )
+#     df_regions = pd.DataFrame(region_props)
+#     # Pack the results into a single output variable (dictionary)
+#     output = {
+#         "img": image,
+#         "img_array": image_array,
+#         "img_scale": normalized_image,
+#         "img_binary": binary_image,
+#         "img_clean": cleaned_image,
+#         "img_label": label_image,
+#         "img_overlay": overlay_image,
+#         "thr_val": thr_val,
+#         "regions": regions,
+#         "df_regions": df_regions,
+#     }
+
+#     return output
+
+
 def cal_pearson(img1, img2):
     """Compute Pearson correlation coefficient between two images."""
     img1_flat = img1.flatten()
@@ -134,3 +362,229 @@ def cal_manders(img1, img2):
     img2_binary = img2 > filters.threshold_otsu(img2)
     overlap_coef = np.sum(img1_binary & img2_binary) / np.sum(img1_binary)
     return overlap_coef
+
+
+def overlay_imgs(
+    *imgs,
+    image=None,
+    colors=None,
+    alpha=0.3,
+    bg_label=0,
+    bg_color=(0, 0, 0),
+    image_alpha=1,
+    kind="overlay",
+    saturation=0,
+    channel_axis=-1,
+):
+    # Ensure all input images have the same shape
+    print(
+        f'\nusage:\nich2ls.overlay_imgs(res_b["img_binary"], res_r["img_binary"], bg_label=0)'
+    )
+    shapes = [img.shape for img in imgs]
+    if not all(shape == shapes[0] for shape in shapes):
+        raise ValueError("All input images must have the same shape")
+
+    # If no image is provided, use the first input image as the base
+    if image is None:
+        image = imgs[0]
+
+    # Combine the images into a label, with unique multipliers for each image
+    label = sum((img.astype(np.uint) * (i + 1) for i, img in enumerate(imgs)))
+
+    # Create the overlay image
+    overlay_image = color.label2rgb(
+        label,
+        image=image,
+        bg_label=bg_label,
+        colors=colors,
+        alpha=alpha,
+        bg_color=bg_color,
+        image_alpha=image_alpha,
+        saturation=saturation,
+        kind=kind,
+        channel_axis=channel_axis,  # Corrected from saturation to channel_axis
+    )
+
+    return overlay_image
+
+
+from skimage import exposure
+
+
+# Comparing edge-based and region-based segmentation
+def draw_hist(img, ax=None, **kwargs):
+    """
+    _, axs = plt.subplots(1, 2)
+    draw_hist(image, c="r", ax=axs[1], lw=2, ls=":")
+    """
+    print(f"img type: {type(img)}")
+    if not isinstance(img, np.ndarray):
+        img = np.array(img)
+    hist, hist_centers = exposure.histogram(img)
+    if ax is None:
+        ax = plt.gca()
+    ax.plot(hist_centers, hist, **kwargs)
+
+
+from skimage import feature
+
+
+# delineate the contours of the coins using edge-based segmentation
+def cal_edges(img, plot=False, cmap=plt.cm.gray):
+    edges = feature.canny(img)
+    if plot:
+        plt.imshow(edges, cmap=cmap)
+    return edges
+
+
+from scipy import ndimage as ndi
+
+
+# These contours are then filled using mathematical morphology.
+def fill_holes(img, plot=False):
+    img_fill_holes = ndi.binary_fill_holes(img)
+    if plot:
+        plt.imshow(img_fill_holes, cmap=plt.cm.gray)
+    return img_fill_holes
+
+
+from skimage import morphology
+
+
+def remove_holes(img, size=50, plot=False):
+    img_rm_holes = morphology.remove_small_objects(img, size)
+    if plot:
+        plt.imshow(img_rm_holes, cmap=plt.cm.gray)
+    return img_rm_holes
+
+
+import matplotlib.patches as mpatches
+from skimage import measure, color
+
+
+def draw_bbox(
+    img,
+    df=None,
+    img_label=None,
+    img_label2rgb=None,
+    show=True,  # plot the image
+    bg_alpha=1,  # the alpha of the bg image
+    area_min=1,
+    area_max=None,
+    fill=False,
+    edgecolor="red",
+    linewidth=2,
+    ax=None,
+    **kwargs,
+):
+    """
+    ich2ls.draw_bbox(
+    res["img_label"], fill=False, color="r", lw=1, edgecolor="w", alpha=0.4)
+    """
+    if ax is None:
+        ax = plt.gca()
+    if img_label is None:
+        img_label = measure.label(img)
+    if isinstance(show, bool):
+        if show:
+            if img_label2rgb is None:
+                img_label2rgb = color.label2rgb(img_label, image=img, bg_label=0)
+            ax.imshow(img_label2rgb, alpha=bg_alpha)
+    elif isinstance(show, str):
+        if "raw" in show:
+            ax.imshow(img, alpha=bg_alpha)
+        elif "label" in show:
+            ax.imshow(img_label, alpha=bg_alpha)
+        elif "rgb" in show:
+            if img_label2rgb is None:
+                img_label2rgb = color.label2rgb(img_label, image=img, bg_label=0)
+            ax.imshow(img_label2rgb, alpha=bg_alpha)
+        elif "no" in show.lower():
+            pass
+    num = 0
+    if df is None:
+        for region in measure.regionprops(img_label):
+            # take regions with large enough areas
+            if area_max is None:
+                area_max = np.inf
+            if area_min <= region.area <= area_max:
+                minr, minc, maxr, maxc = region.bbox
+                rect = mpatches.Rectangle(
+                    (minc, minr),
+                    maxc - minc,
+                    maxr - minr,
+                    fill=fill,
+                    edgecolor=edgecolor,
+                    linewidth=linewidth,
+                    **kwargs,
+                )
+                ax.add_patch(rect)
+                num += 1
+    else:
+        # Iterate over each row in the DataFrame and draw the bounding boxes
+        for _, row in df.iterrows():
+            minr = row["bbox-0"]
+            minc = row["bbox-1"]
+            maxr = row["bbox-2"]
+            maxc = row["bbox-3"]
+
+            # Optionally filter by area if needed
+            area = (maxr - minr) * (maxc - minc)
+            if area >= area_min:
+                rect = mpatches.Rectangle(
+                    (minc, minr),
+                    maxc - minc,
+                    maxr - minr,
+                    fill=fill,
+                    edgecolor=edgecolor,
+                    linewidth=linewidth,
+                    **kwargs,
+                )
+                ax.add_patch(rect)
+                num += 1
+    return num
+
+
+props_list = [
+    "area",  # Number of pixels in the region. Useful for determining the size of regions.
+    "area_bbox",
+    "area_convex",
+    "area_filled",
+    "axis_major_length",  # Lengths of the major and minor axes of the ellipse that fits the region. Useful for understanding the shape's elongation and orientation.
+    "axis_minor_length",
+    "bbox",  # Bounding box coordinates (min_row, min_col, max_row, max_col). Useful for spatial localization of regions.
+    "centroid",  # Center of mass coordinates (centroid-0, centroid-1). Helps locate the center of each region.
+    "centroid_local",
+    "centroid_weighted",
+    "centroid_weighted_local",
+    "coords",
+    "eccentricity",  # Measure of how elongated the region is. Values range from 0 (circular) to 1 (line). Useful for assessing the shape of regions.
+    "equivalent_diameter_area",  # Diameter of a circle with the same area as the region. Provides a simple measure of size.
+    "euler_number",
+    "extent",  # Ratio of the region's area to the area of its bounding box. Indicates how much of the bounding box is filled by the region.
+    "feret_diameter_max",  # Maximum diameter of the region, providing another measure of size.
+    "image",
+    "image_convex",
+    "image_filled",
+    "image_intensity",
+    "inertia_tensor",  # ensor describing the distribution of mass in the region, useful for more advanced shape analysis.
+    "inertia_tensor_eigvals",
+    "intensity_max",  # Maximum intensity value within the region. Helps identify regions with high-intensity features.
+    "intensity_mean",  # Average intensity value within the region. Useful for distinguishing between regions based on their brightness.
+    "intensity_min",  # Minimum intensity value within the region. Useful for regions with varying intensity.
+    "intensity_std",
+    "label",  # Unique identifier for each region.
+    "moments",
+    "moments_central",
+    "moments_hu",  # Hu moments are a set of seven invariant features that describe the shape of the region. Useful for shape recognition and classification.
+    "moments_normalized",
+    "moments_weighted",
+    "moments_weighted_central",
+    "moments_weighted_hu",
+    "moments_weighted_normalized",
+    "orientation",  # ngle of the major axis of the ellipse that fits the region. Useful for determining the orientation of elongated regions.
+    "perimeter",  # Length of the boundary of the region. Useful for shape analysis.
+    "perimeter_crofton",
+    "slice",
+    "solidity",  # Ratio of the area of the region to the area of its convex hull. Indicates how solid or compact a region is.
+]

py2ls/netfinder.py

@@ -671,8 +671,8 @@ def downloader(
     if dir_save:
         if rm_folder:
             ips.rm_folder(dir_save)
-        if verbose:
-            print(f"\n... attempting to download to local\n")
+        # if verbose:
+        #     print(f"\n... attempting to download to local\n")
         fnames = [file_link.split("/")[-1] for file_link in file_links_all]
 
         for idx, file_link in enumerate(file_links_all):
@@ -688,6 +688,9 @@ def downloader(
                         ext = next(
                             (ftype for ftype in kind if ftype in file_link), None
                         )
+                        if ext is None:
+                            ext = kind_
+                        print("ehereerere", ext)
                         if ext:
                             corrected_fname = fname_corrector(fnames[idx], ext)
                             corrected_fname = check_and_modify_filename(

py2ls/plot.py

@@ -1823,15 +1823,43 @@ def get_color(
         cmap = "grey"
     # Determine color list based on cmap parameter
     if "aut" in cmap:
-        colorlist = [
-            "#474747",
-            "#FF2C00",
-            "#0C5DA5",
-            "#845B97",
-            "#58BBCC",
-            "#FF9500",
-            "#D57DBE",
-        ]
+        if n == 1:
+            colorlist = ["#3A4453"]
+        elif n == 2:
+            colorlist = ["#3A4453", "#DF5932"]
+        elif n == 3:
+            colorlist = ["#3A4453", "#DF5932", "#299D8F"]
+        elif n == 4:
+            # colorlist = ["#3A4453", "#DF5932", "#EBAA00", "#0B4083"]
+            colorlist = ["#81C6BD", "#FBAF63", "#F2675B", "#72A1C9"]
+        elif n == 5:
+            colorlist = [
+                "#3A4453",
+                "#427AB2",
+                "#F09148",
+                "#DBDB8D",
+                "#C59D94",
+                "#AFC7E8",
+            ]
+        elif n == 6:
+            colorlist = [
+                "#3A4453",
+                "#427AB2",
+                "#F09148",
+                "#DBDB8D",
+                "#C59D94",
+                "#E53528",
+            ]
+        else:
+            colorlist = [
+                "#474747",
+                "#FF2C00",
+                "#0C5DA5",
+                "#845B97",
+                "#58BBCC",
+                "#FF9500",
+                "#D57DBE",
+            ]
         by = "start"
     elif any(["cub" in cmap.lower(), "sns" in cmap.lower()]):
         if kwargs:
@@ -1909,6 +1937,10 @@ import matplotlib.pyplot as plt
 
 
 def stdshade(ax=None, *args, **kwargs):
+    """
+    usage:
+    plot.stdshade(data_array, c=clist[1], lw=2, ls="-.", alpha=0.2)
+    """
     # Separate kws_line and kws_fill if necessary
     kws_line = kwargs.pop("kws_line", {})
     kws_fill = kwargs.pop("kws_fill", {})
@@ -1946,8 +1978,9 @@ def stdshade(ax=None, *args, **kwargs):
         ax = plt.gca()
     if ax is None:
         ax = plt.gca()
-    alpha = 0.5
-    acolor = "k"
+    alpha = kwargs.get("alpha", 0.2)
+    acolor = kwargs.get("color", "k")
+    acolor = kwargs.get("c", "k")
     paraStdSem = "sem"
     plotStyle = "-"
     plotMarker = "none"

{py2ls-0.1.9.9.dist-info → py2ls-0.1.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py2ls
-Version: 0.1.9.9
+Version: 0.1.10.0
 Summary: py(thon)2(too)ls
 Author: Jianfeng
 Author-email: Jianfeng.Liu0413@gmail.com

{py2ls-0.1.9.9.dist-info → py2ls-0.1.10.0.dist-info}/RECORD

@@ -144,6 +144,7 @@ py2ls/.gitignore,sha256=y7GvbD_zZkjPVVIue8AyiuFkDMuUbvMaV65Lgu89To8,2763
 py2ls/LICENSE,sha256=UOZ1F5fFDe3XXvG4oNnkL1-Ecun7zpHzRxjp-XsMeAo,11324
 py2ls/README.md,sha256=CwvJWAnSXnCnrVHlnEbrxxi6MbjbE_MT6DH2D53S818,11572
 py2ls/__init__.py,sha256=Nn8jTIvySX7t7DMJ8VNRVctTStgXGjHldOIdZ35PdW8,165
+py2ls/batman.py,sha256=CSM3PxXE4Qpt_yVfaAgMUAGZuJCG_PGkENjG_Mjev4k,5717
 py2ls/brain_atlas.py,sha256=w1o5EelRjq89zuFJUNSz4Da8HnTCwAwDAZ4NU4a-bAY,5486
 py2ls/chat.py,sha256=Yr22GoIvoWhpV3m4fdwV_I0Mn77La346_ymSinR-ORA,3793
 py2ls/correlators.py,sha256=RbOaJIPLCHJtUm5SFi_4dCJ7VFUPWR0PErfK3K26ad4,18243
@@ -176,15 +177,15 @@ py2ls/db2ls.py,sha256=MMfFX47aIPIyu7fU9aPvX9lbPRPYOpJ_VXwlnWk-8qo,13615
 py2ls/doc.py,sha256=xN3g1OWfoaGUhikbJ0NqbN5eKy1VZVvWwRlhHMgyVEc,4243
 py2ls/export_requirements.py,sha256=x2WgUF0jYKz9GfA1MVKN-MdsM-oQ8yUeC6Ua8oCymio,2325
 py2ls/freqanalysis.py,sha256=F4218VSPbgL5tnngh6xNCYuNnfR-F_QjECUUxrPYZss,32594
-py2ls/ich2ls.py,sha256=LYoMjU8fRJrtu_ZAnIAQkZVs2Vdoy7RvyUGA9Fq_Pt4,5995
+py2ls/ich2ls.py,sha256=3E9R8oVpyYZXH5PiIQgT3CN5NxLe4Dwtm2LwaeacE6I,21381
 py2ls/ips.py,sha256=HbktFzKIszBHtB3DtyUCCM6xj9NJZAz38ZCcIomjBFs,105439
-py2ls/netfinder.py,sha256=oo8Nyqe9Oi3TON7YS9TCs2RBUjPY3KY7772DrsNPkyU,50679
-py2ls/plot.py,sha256=pMopJJSapyUwAFaoizwJMGSawGFVQFcAPDOh1vFM7N4,94253
+py2ls/netfinder.py,sha256=xma9YoBxY4GcgoyG4YXEOU8oKPYByIt0uWqPyshHt8s,50812
+py2ls/plot.py,sha256=9z0VPvMTFsuYKakuHjTGKK6UtiQylM3-WCxbNEKxTos,95283
 py2ls/setuptools-70.1.0-py3-none-any.whl,sha256=2bi3cUVal8ip86s0SOvgspteEF8SKLukECi-EWmFomc,882588
 py2ls/sleep_events_detectors.py,sha256=bQA3HJqv5qnYKJJEIhCyhlDtkXQfIzqksnD0YRXso68,52145
 py2ls/stats.py,sha256=fJmXQ9Lq460StOn-kfEljE97cySq7876HUPTnpB5hLs,38123
 py2ls/translator.py,sha256=bc5FB-wqC4TtQz9gyCP1mE38HqNRJ_pmuRIgKnAlMzM,30581
 py2ls/wb_detector.py,sha256=7y6TmBUj9exCZeIgBAJ_9hwuhkDh1x_-yg4dvNY1_GQ,6284
-py2ls-0.1.9.9.dist-info/METADATA,sha256=tRTwCfUkzWCGXAIkgA3xlBL4jUN7V6GI-4P4IcSg4Fc,20017
-py2ls-0.1.9.9.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-py2ls-0.1.9.9.dist-info/RECORD,,
+py2ls-0.1.10.0.dist-info/METADATA,sha256=76w1Clumy3D_fhABBpVwMaJV_49n-MJnOVRHW3wiaJY,20018
+py2ls-0.1.10.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+py2ls-0.1.10.0.dist-info/RECORD,,