easysurfvis 0.0.1__tar.gz

easysurfvis-0.0.1/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include src/easysurfvis/data *

easysurfvis-0.0.1/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: easysurfvis
+Version: 0.0.1
+Summary: visualize surface map easily
+Home-page: https://github.com/SeojinYoon/easy_surf_vis
+Author: seojin
+Author-email: pures1@hanyang.ac.kr
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: pandas
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+# easysurfvis
+
+This library is based on rsatoolbox(https://github.com/rsagroup/rsatoolbox).
+
+# Installation
+- pip install easysurfvis
+
+# Dependencies
+
+- numpy
+- SUITPy
+- matplotlib
+
+# License - GPL-3.0 license

easysurfvis-0.0.1/README.md

@@ -0,0 +1,15 @@
+
+# easysurfvis
+
+This library is based on rsatoolbox(https://github.com/rsagroup/rsatoolbox).
+
+# Installation
+- pip install easysurfvis
+
+# Dependencies
+
+- numpy
+- SUITPy
+- matplotlib
+
+# License - GPL-3.0 license

easysurfvis-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

easysurfvis-0.0.1/setup.py

@@ -0,0 +1,32 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setup(
+    name = "easysurfvis",
+    version = "0.0.1",
+    author = "seojin",
+    author_email = "pures1@hanyang.ac.kr",
+    description = "visualize surface map easily",
+    long_description = long_description,
+    long_description_content_type="text/markdown",
+    url = "https://github.com/SeojinYoon/easy_surf_vis",
+    
+    packages = find_packages(where = "src"),
+    package_dir = {"": "src"},
+    
+    include_package_data=True,
+    
+    classifiers = [
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires='>=3.8',
+    install_requires = [
+        "numpy",
+        "pandas",
+    ]
+)
+

easysurfvis-0.0.1/src/easysurfvis/cores/afni_extension.py

@@ -0,0 +1,206 @@
+
+# Common Libraries
+import os
+import subprocess
+import numpy as np
+import pandas as pd
+
+# Custom Libraries
+if os.getenv("easysurfvis_isRunSource"):
+    sys.path.append(os.getenv("easysurfvis_source_home"))
+    from cores.general_util import get_multiple_elements_in_list
+else:
+    from easysurfvis.cores.general_util import get_multiple_elements_in_list
+
+# Functions
+def set_afni_abin(abin_path):
+    """
+    set abin path
+    
+    :param abin_path: path of afni binnary ex) "/Users/clmn/abin/afni"
+    """
+    os.environ['PATH'] = os.environ['PATH'] + ":" + abin_path
+        
+def whereami(x, 
+             y, 
+             z, 
+             coord = "spm", 
+             atlas = None, 
+             is_show_command = False, 
+             is_parsing = True):
+    """
+    Where is the location?
+
+    https://afni.nimh.nih.gov/pub/dist/doc/program_help/whereami.html
+
+    :param x: (int)
+    :param y: (int)
+    :param z: (int)
+    :param coord: (string) spm, dicom
+        -meaning spm: is equal to RAS+, lpi coords
+        -meaning dicom: is equal to LPS+ rai coords
+        
+    :param atlas: (string)
+        -Haskins_Pediatric_Nonlinear_1.0
+        -CA_ML_18_MNI
+        -and so on...
+        
+    return (pd.DataFrame)
+        -row: atlas info
+    """
+    
+    if atlas != None:
+        command = f"whereami {x} {y} {z} -{coord} -atlas {atlas}"
+    else:
+        command = f"whereami {x} {y} {z} -{coord}"
+        
+    if is_show_command:
+        print(command)
+        
+    # command
+    output = subprocess.check_output(command, shell=True)
+    output = output.decode('utf-8').split("\n")
+
+    if is_parsing == False:
+        return output
+    else:
+        atlas_lines = search_stringAcrossTarget(output, 
+                                                search_keys = ["Atlas"], 
+                                                exclude_keys=["nearby"], 
+                                                return_type = "index")
+        
+        search_atlas = []
+        search_infos = []
+        search_names = []
+        for i in range(len(atlas_lines)):
+            if len(atlas_lines) == 1:
+                start_line_i = atlas_lines[0]
+                end_line_i = search_stringAcrossTarget(output, 
+                                                       search_keys = ["Please", "caution"], 
+                                                       return_type = "index")[0]
+            else:
+                if i + 1 < len(atlas_lines):
+                    # Search region name based on each atlas
+                    start_line_i = atlas_lines[i]
+                    end_line_i = atlas_lines[i+1] - 1
+                else:
+                    continue
+
+            atlas_name = output[start_line_i].split(": ")[0].replace("Atlas ", "")
+            selected_output = output[start_line_i:end_line_i]
+
+            # search result
+            search_results = search_stringAcrossTarget(selected_output, 
+                                                       search_keys = ["Focus", "Within"], 
+                                                       search_type = "any")
+
+            for result in search_results:
+                sp_result = result.split(":")
+
+                info = sp_result[0].strip()
+                name = sp_result[1].strip()
+
+                search_atlas.append(atlas_name)
+                search_infos.append(info)
+                search_names.append(name)
+            
+            
+        result_df = pd.DataFrame({
+            "atlas" : search_atlas,
+            "info" : search_infos,
+            "name" : search_names,
+        })
+
+        return result_df
+
+def search_string(target, search_keys, search_type = "any", exclude_keys = []):
+    """
+    Search string with keys in target
+    
+    :param target(str): target string
+    :param keys(list - str): search key
+    :param search_type(str): search type - 'any', 'all', any is 'or' condition, all is 'and' condition
+    :param exclude_keys(list - str): exclude key
+    
+    return boolean
+    """
+    if search_type == "any":
+        search_result = any([key in target for key in search_keys])
+    elif search_type == "all":
+        search_result = all([key in target for key in search_keys])
+    elif search_type == "correct":
+        assert(len(search_keys) == 1), "please input only one search key"
+        search_result = search_keys[0] == target
+    
+    if exclude_keys != None and exclude_keys != []:
+        exclude_result = not any([key in target for key in exclude_keys])
+    
+        return search_result and exclude_result
+    else:
+        return search_result
+
+def search_stringAcrossTarget(targets, 
+                              search_keys,
+                              search_type = "any", 
+                              exclude_keys = [], 
+                              validation_type = None,
+                              return_type = "string"):
+    """
+    Search string across target strings
+    
+    :param target(list): target string
+    :param keys(str): search key
+    :param search_type(str): search type - 'any', 'all', any is or condition, all is and condition
+    :param exclude_keys(list - str): exclude key
+    :param validation_type(File_validation): kinds of validation checking from search result
+    :param return_type(string): 'string' or 'index'
+    
+    return list of searched string
+    """
+    search_results = [search_string(target = target, 
+                                    search_keys = search_keys, 
+                                    search_type = search_type,
+                                    exclude_keys = exclude_keys) for target in targets]
+    search_flags = np.array(search_results)
+    indexes = np.where(search_flags == True)[0]
+    result = get_multiple_elements_in_list(targets, indexes)
+    
+    # search validation
+    if validation_type == None:
+        pass
+    else:
+        if validation_type.value & File_validation.exist.value != 0:
+            # Check the search result existed
+            assert len(result) != 0, "Please check to exist file"
+        if validation_type.value & File_validation.only.value != 0:
+            if len(result) > 1:
+                print(result)
+                raise Exception("Multiple similar files")
+    
+    # return
+    def return_func():
+        if return_type == "index":
+            return indexes
+        elif return_type == "flag":
+            return search_flags
+        else:
+            return result
+        
+    if validation_type == None:
+        return return_func()
+    else:        
+        if validation_type.value & File_validation.only.value != 0:
+            if return_type == "index":
+                return indexes[0]
+            elif return_type == "flag":
+                return search_flags
+            else:
+                return result[0]
+        else:
+            return return_func()
+
+
+    
+if __name__ == "__main__":
+    set_afni_abin("/Users/clmn/abin/afni")
+    whereami(x = 10, y = 10, z = 10)

easysurfvis-0.0.1/src/easysurfvis/cores/custom_matplotlib.py

@@ -0,0 +1,218 @@
+
+"""
+This file contains the basic source code to visualize graph using matplotlib
+"""
+# Common Libraries
+import numpy as np
+import matplotlib.pylab as plt
+from scipy.stats import cumfreq
+from matplotlib.lines import Line2D
+from matplotlib.ticker import FuncFormatter
+
+# Custom Libraries
+if os.getenv("easysurfvis_isRunSource"):
+    sys.path.append(os.getenv("easysurfvis_source_home"))
+    from cores.general_util import search_stringAcrossTarget, find_consecutive_ranges
+else:
+    from easysurfvis.cores.general_util import search_stringAcrossTarget, find_consecutive_ranges
+
+# Functions
+def draw_title(axis, title_info = {}):
+    """
+    Draw title in the axis
+    
+    :param title_info(dictionary): 
+         -k, title(string): title
+         -k, title_weight(string): weight of font
+         -k, title_size(string): size of title
+         -k, title_y_pos(string): y pos of title
+    """
+    title = title_info.get("title", "")
+    title_weight = title_info.get("title_weight", "bold")
+    title_size = title_info.get("title_size", 20)
+    title_y_pos = title_info.get("title_y_pos", 1.0)
+    
+    axis.set_title(title, 
+                   fontweight = title_weight,
+                   size = title_size, 
+                   y = title_y_pos)
+        
+def draw_label(axis, label_info = {}):
+    """
+    Draw label in the axis
+    
+    :param label_info(dictionary): 
+        -k, color(string): label color
+        -k, x_label(string): x label text
+        -k, y_label(string): y label text
+        -k, x_weight(string): x label weight
+        -k, y_weight(string): y label weight
+        -k, x_size(float): x label size
+        -k, y_size(float): y label size
+    """
+    color = label_info.get("color", "black")
+    
+    x_label = label_info.get("x_label", "")
+    y_label = label_info.get("y_label", "")
+    
+    x_weight = label_info.get("x_weight", "normal")
+    y_weight = label_info.get("y_weight", "normal")
+
+    x_label_size = label_info.get("x_size", 16)
+    y_label_size = label_info.get("y_size", 16)
+    
+    x_label_pad = label_info.get("x_label_pad", 10)
+    y_label_pad = label_info.get("y_label_pad", 10)
+    
+    axis.set_xlabel(x_label, 
+                    color = color, 
+                    weight = x_weight, 
+                    size = x_label_size,
+                    labelpad = x_label_pad)
+
+    axis.set_ylabel(y_label, 
+                    color = color, 
+                    weight = y_weight, 
+                    size = y_label_size,
+                    labelpad = y_label_pad)
+            
+def draw_ticks(axis, tick_info = {}):
+    """
+    Draw ticks in the axis
+    
+    :param tick_info(dictionary): tick style configuration
+        -k, x_data(list): x tick positions ex) [1,2,3]
+        -k, x_names(list): x tick text ex) ["a", "b", "c"]
+        -k, x_tick_weight(string): x tick weight
+        -k, x_tick_size(float): x tick size
+        -k, x_tick_rotation(int): x tick rotation
+        
+        -k, y_data(list): y tick positions ex) [1,2,3]
+        -k, y_names(list): y tick text ex) ["a", "b", "c"] 
+        -k, y_tick_precision(float): Number of decimal places to display on y-axis ticks
+        -k, y_tick_weight(string): y tick weight
+        -k, y_tick_size(float): y tick size
+        -k, y_tick_rotation(int): y tick rotation
+        -k, y_divided(int): the number of division for showing y-tick
+        -k, y_need_tick(list): the y-tick which must to show
+    """
+    x_data = tick_info.get("x_data", [])
+    x_names = tick_info.get("x_names", [])
+    
+    x_tick_weight = tick_info.get("x_tick_weight", "normal")
+    x_tick_size = tick_info.get("x_tick_size", 14)
+    x_tick_rotation = tick_info.get("x_tick_rotation", 90)
+    x_tick_viewType = tick_info.get("x_tick_viewType", "remove_duplication")
+    
+    y_data = tick_info.get("y_data", [])
+    y_names = tick_info.get("y_names", [])
+    
+    y_tick_weight = tick_info.get("y_tick_weight", "normal")
+    y_tick_size = tick_info.get("y_tick_size", 14)
+    y_tick_rotation = tick_info.get("y_tick_rotation", 0)
+    y_tick_precision = tick_info.get("y_tick_precision", None)
+    
+    # X
+    x_data = np.array(x_data)
+    x_names = np.array(x_names)
+    
+    if x_tick_viewType == "remove_duplication":
+        x_tick_duplication = np.array([int((start + end) / 2) for start, end in find_consecutive_ranges(x_names)], dtype = int)
+        x_tick_data = np.array([(x_data[start] + x_data[end]) / 2 for start, end in find_consecutive_ranges(x_names)])
+        
+        if len(x_tick_duplication) > 0:
+            x_names = x_names[x_tick_duplication]
+            x_data = x_tick_data
+        
+    axis.set_xticks(x_data, 
+                    x_names, 
+                    rotation = x_tick_rotation, 
+                    weight = x_tick_weight, 
+                    size = x_tick_size)
+    
+    # Y
+    axis.set_yticks(y_data, 
+                    y_names,
+                    rotation = y_tick_rotation,
+                    weight = y_tick_weight,
+                    size = y_tick_size)
+    if y_tick_precision is not None:
+        axis.yaxis.set_major_formatter(FuncFormatter(lambda y, _: f"{y:.{y_tick_precision}f}"))
+        
+def draw_spine(axis, spine_info = {}):
+    """
+    Draw spine in the axis
+    
+    :param spine_info(dictionary): 
+        -k, spine_linewidth(float): spine line width ex) 2
+        -k, spine_color(string): spine line color ex) "black"
+        -k, invisibles(list): invisible informations ex) ["right", "top"]
+    """
+    spine_line_width = spine_info.get("spine_linewidth", 1)
+    spine_color = spine_info.get("spine_color", "black")
+    invisibles = spine_info.get("invisibles", ["right", "top"])
+    
+    all_spines = ["bottom", "top", "left", "right"]
+    for invisible in invisibles:
+        axis.spines[invisible].set_visible(False)
+        all_spines.remove(invisible)
+        
+    for ax_name in all_spines:
+        axis.spines[ax_name].set_linewidth(spine_line_width)
+        axis.spines[ax_name].set_linewidth(spine_line_width)
+        axis.spines[ax_name].set_color(spine_color)
+
+def make_colorbar(vmin, 
+                  vmax, 
+                  figsize = (2, 6), 
+                  n_inner_ticks = 3, 
+                  cmap = "jet", 
+                  tick_precision = 4, 
+                  orientation = "horizontal",
+                  fontsize = 12):
+    """
+    Creates a customizable colorbar using matplotlib.
+
+
+    :param vmin (float): The minimum value for the colorbar.
+    :param vmax (float): The maximum value for the colorbar.
+    :param figsize (tuple): The size of the figure (width, height). Defaults to (2, 6).
+    :param n_div (int): Number of divisions (ticks) on the colorbar. Defaults to 4.
+    :param cmap (str): Colormap to use for the colorbar. Defaults to "jet".
+    :param tick_precision (int): Number of decimal places to display on the tick labels. Defaults to 4.
+    :param orientation (str): Orientation of the colorbar, either "horizontal" or "vertical". Defaults to "horizontal".
+
+    return (tuple): A tuple containing the matplotlib figure and axis objects.
+    """
+    n_div = n_inner_ticks + 1
+    
+    interval = (vmax - vmin) / n_div
+    ticks = np.linspace(vmin, vmax, n_div + 1)
+
+    # Create the figure and axis for the colorbar
+    fig = plt.figure(figsize = figsize)
+
+    if orientation == "vertical":
+        axis = fig.add_axes([0.05, 0.05, 0.15, 0.9])  # [left, bottom, width, height]
+    else:
+        axis = fig.add_axes([0.1, 0.5, 0.8, 0.3])  # [left, bottom, width, height]
+    
+    # Create the colorbar
+    cmap = plt.get_cmap(cmap)
+    norm = plt.Normalize(vmin = vmin, vmax = vmax)
+    cbar = fig.colorbar(plt.cm.ScalarMappable(norm=norm, cmap=cmap), cax=axis, orientation=orientation)
+    
+    # Set the ticks and labels
+    if orientation == "vertical":
+        axis.set_yticks(ticks)
+        axis.set_yticklabels([f"{tick:.{tick_precision}f}" for tick in ticks], fontsize = fontsize)
+        axis.get_xaxis().set_visible(False)
+    else:
+        axis.set_xticks(ticks)
+        axis.set_xticklabels([f"{tick:.{tick_precision}f}" for tick in ticks], fontsize = fontsize)
+        axis.get_yaxis().set_visible(False)
+    
+    return fig, axis, ticks
+
+if __name__=="__main__":
+    pass

easysurfvis-0.0.1/src/easysurfvis/cores/general_util.py

@@ -0,0 +1,150 @@
+
+# Common Libraries
+import re
+import numpy as np
+from enum import Enum
+
+# Classes
+class File_validation(Enum):
+    exist = 1 << 0
+    only = 1 << 1
+    
+    exist_only = exist | only
+    
+# Functions
+def search_string(target, search_keys, search_type = "any", exclude_keys = []):
+    """
+    Search string with keys in target
+    
+    :param target(str): target string
+    :param keys(list - str): search key
+    :param search_type(str): search type - 'any', 'all', any is 'or' condition, all is 'and' condition
+    :param exclude_keys(list - str): exclude key
+    
+    return boolean
+    """
+    if search_type == "any":
+        search_result = any([key in target for key in search_keys])
+    elif search_type == "all":
+        search_result = all([key in target for key in search_keys])
+    elif search_type == "correct":
+        assert(len(search_keys) == 1), "please input only one search key"
+        search_result = search_keys[0] == target
+    
+    if exclude_keys != None and exclude_keys != []:
+        exclude_result = not any([key in target for key in exclude_keys])
+    
+        return search_result and exclude_result
+    else:
+        return search_result
+
+def search_stringAcrossTarget(targets, 
+                              search_keys,
+                              search_type = "any", 
+                              exclude_keys = [], 
+                              validation_type = None,
+                              return_type = "string"):
+    """
+    Search string across target strings
+    
+    :param target(list): target string
+    :param keys(str): search key
+    :param search_type(str): search type - 'any', 'all', any is or condition, all is and condition
+    :param exclude_keys(list - str): exclude key
+    :param validation_type(File_validation): kinds of validation checking from search result
+    :param return_type(string): 'string' or 'index'
+    
+    return list of searched string
+    """
+    search_results = [search_string(target = target, 
+                                    search_keys = search_keys, 
+                                    search_type = search_type,
+                                    exclude_keys = exclude_keys) for target in targets]
+    search_flags = np.array(search_results)
+    indexes = np.where(search_flags == True)[0]
+    result = list(np.array(targets)[indexes])
+    
+    # search validation
+    if validation_type is not None:
+        if validation_type.value & File_validation.exist.value != 0: # check existence
+            assert len(result) != 0, "Please check to exist file"
+        if validation_type.value & File_validation.only.value != 0: # check the number of files
+            if len(result) > 1:
+                raise Exception("Multiple similar files")
+    
+    # return
+    if return_type == "index":
+        out = indexes
+    elif return_type == "flag":
+        out = search_flags
+    else:
+        out = results
+
+    # only 옵션이면 scalar로 축약
+    if (validation_type is not None
+        and (validation_type.value & File_validation.only.value)
+        and return_type != "flag"
+    ):
+        return out[0]
+
+    return out
+
+def find_consecutive_ranges(data):
+    """
+    Find index ranges of consecutive identical values
+    
+    :param data: (list)
+    
+    return [(start index, stop index)]
+    """
+    if not isinstance(data, list):
+        data = list(data)
+    
+    if not data:
+        return []
+
+    result = []
+    start = 0
+
+    for i in range(1, len(data)):
+        if data[i] != data[i - 1]:
+            result.append((start, i - 1))
+            start = i
+
+    result.append((start, len(data) - 1))
+    return result
+
+def get_multiple_elements_in_list(in_list, in_indices):
+    """
+    Get multiple element using indexes
+    
+    :param in_list: data(list)
+    :param in_indices: indexes to be extracted from in_list
+    """
+    return [in_list[i] for i in in_indices]
+
+def get_unique_values(data):
+    """
+    Get unique values from data
+    
+    :param data: (list)
+    
+    return (list)
+    """
+    
+    unique_values = []
+    for e in data:
+        if e in unique_values:
+            pass
+        else:
+            unique_values.append(e)
+    return unique_values
+    
+# Examples                      
+if __name__ == "__main__":
+    a_string = "A string is more than its parts!"
+    matches = ["more", "d"]
+    search_string(a_string, matches, search_type = "all")
+    
+    search_stringAcrossTarget(targets = ["1","2","3"], search_keys=["1"], return_type = "flag")
+    find_consecutive_ranges([1,1,2,3])