DiaModality 0.1.3__py3-none-any.whl

DiaModality/CsvParser.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python
+import csv
+
+
+class LoadCsv:
+    '''
+        The input CSV file must be comma delimited and contains only numeric 
+        data or empty cells. Each empty cell concideres as None.
+    '''
+
+    def __init__(self, file_path: str) -> None:
+        self.file_path = file_path
+
+    def ParseCsv(self, *args) -> list:
+        '''
+            The input is a list of integers. 
+            Output is list of matrices.
+            Each int represent each output matrix and defines
+            how many columns to include into matrix.
+            Eg: input: (3, 2)
+                output: list of two matrices, first one with 1-3 cols 
+                        and second one with 4-5 cols from the original csv.
+        '''
+
+        with open(self.file_path, 'r') as file:
+            reader = csv.reader(file)
+            table = tuple(reader)
+            output = []
+
+            for i, arg in enumerate(args):
+
+                output.append([])
+                start = sum(args) - sum(args[i:])
+                stop = start + arg
+
+                for row in table:
+                    output[i].append(
+                        tuple(
+                            float(cell) if cell 
+                            else None 
+                            for cell in row[start:stop]
+                        )
+                    )
+
+        return output
+
+    def ParseCsv_old(self) -> list:
+        '''
+            Ugly legacy method specific for modality plot only
+            to be removed if new one works well
+        '''
+        with open(self.file_path, 'r') as file:
+            reader = csv.reader(file)
+            data, binarization = [], []
+            for row in reader:
+                data.append(
+                    tuple(
+                        float(cell)
+                        if cell
+                        else 0
+                        for cell in row[:3]
+                    )
+                )
+                binarization.append(
+                    tuple(
+                        True 
+                        if cell 
+                        else False 
+                        for cell in row[3:6]
+                    )
+                )
+
+        return data, binarization
+
+
+if __name__ == '__main__':
+    print('\nThis script can be used as an imported module only\n')

DiaModality/ModalityPlot.py

@@ -0,0 +1,344 @@
+#!/usr/bin/env python
+import matplotlib.pyplot as plt
+# import matplotlib.colors as mcolors
+import matplotlib.gridspec as gridspec
+import numpy as np
+
+# Only use for plot layout adjustment
+DEBUG = False
+
+
+class __Figure():
+    '''
+        Super class of all future plots
+    '''
+
+    def __init__(
+        self,
+        marker='',
+        linestyle='-',
+        linewidth=0.5,
+        alpha=0.8,
+        figsize=(10, 10),
+        title='',
+    ) -> None:
+
+        self.marker = marker
+        self.linestyle = linestyle
+        self.linewidth = linewidth
+        self.alpha = alpha
+        self.figsize = figsize
+        self.title = title
+        self.debug_flag = DEBUG
+
+        # Prepare figure:
+        self.fig = plt.figure(figsize=self.figsize)
+        self._make_layout()
+
+    def _make_layout(self) -> None:
+        # Create figure
+        plt.subplots_adjust(wspace=0.0, hspace=0.0)
+        plt.tight_layout()
+        plt.suptitle(self.title)
+
+
+class __Output():
+    '''
+        Output options mixin
+    '''
+
+    def show(self):
+        plt.show()
+
+    def save(self,
+             filename,
+             type='png',
+             transparent=False):        
+        plt.savefig('{}.{}'.format(filename, type), transparent=transparent)
+
+
+class ModalityPlot(__Figure, __Output):
+    '''
+        Input fotmat:
+
+        data: list of points, each point should be represented as a
+              list or touple containing three floats, one per modality.
+
+    '''
+
+    def __init__(
+        self,
+        data: list,
+        binarization: list,
+        modalities=('Set A', 'Set B', 'Set C'),
+        angles=[90, 210, 330],
+        labels=True,
+        scalecircle=1,             # Scale circle radius
+        scalecircle_linestyle=':',
+        scalecircle_linewidth=1,
+        marker='',                 # vector endpoints marker
+        linestyle='-',
+        linewidth=0.5,
+        alpha=0.8,
+        same_scale=False,          # Draw all the subplots in the same scale
+        full_center=True,          # Draw all vectors in the central subplot, else draw trimodal vectors only
+        whole_sum=True,            # Calculate all three modality vectors despite binarization
+        figsize=(10, 10),
+        title='',
+        colors=(
+            'tab:green',           # Set 1 color
+            'navy',                # Set 2 color
+            'tab:red',             # Set 3 color
+            '#1E88E5',             # Sets 1 & 2 intersection color
+            '#FF9933',             # Sets 1 & 3 intersection color
+            '#9900FF',             # Sets 2 & 3 intersection color
+            'black',               # All sets   intersection color
+        ),
+        normalization_func='sigmoid',
+    ) -> None:
+
+        self.data, self.binarization = self.__format_input(data, binarization)
+        self.modalities = modalities
+        self.angles = np.deg2rad(angles)
+        self.labels = labels
+        self.scalecircle = scalecircle
+        self.scalecircle_linestyle = scalecircle_linestyle
+        self.scalecircle_linewidth = scalecircle_linewidth
+        self.same_scale = same_scale
+        self.full_center = full_center
+        self.whole_sum = whole_sum
+        self.colors = colors
+        self.normalization_func = normalization_func
+        self.modality_patterns = (
+            (True, False, False),
+            (False, True, False),
+            (False, False, True),
+            (True, True, False),
+            (True, False, True),
+            (False, True, True),
+            (True, True, True),
+        )
+        self.modalities_array = (
+            (self.modalities[0], None, None),
+            (None, self.modalities[1], None),
+            (None, None, self.modalities[2]),
+            (self.modalities[0], self.modalities[1], None),
+            (self.modalities[0], None, self.modalities[2]),
+            (None, self.modalities[1], self.modalities[2]),
+            (None, None, None),
+        )
+
+        super().__init__(
+            marker,
+            linestyle,
+            linewidth,
+            alpha,
+            figsize,
+            title,
+        )
+
+        # check input:
+        assert self.data.any(), 'data array must not be empty'
+        assert self.binarization.any(), 'binarization array must not be empty'
+        assert len(self.data) == len(
+            self.binarization), 'data and binarization arrays must have exact length'
+        assert len(self.data[0]) == len(self.binarization[0]
+                                        ) == 3, 'data and binarization arrays must have three columns each'
+
+    def __format_input(self, input_data, input_bin) -> list:
+        '''
+            Data formatting:
+            Each column represents one modality. Empty cells are counted as 0.
+            Each row containing at least one value that will be represented as a point.
+        '''
+
+        output_data = np.array(input_data, dtype=object)
+        # Replace empty cells with zeros
+        output_data[output_data is None] = 0
+        output_data = output_data.astype(np.float32)
+
+        # Replace zeros with False and other numbers with True
+        output_bin = np.array(input_bin, dtype=np.bool_)
+
+        return output_data, output_bin
+
+    def __normalization(self, input) -> list:
+        '''
+            Define function to normalize coordinates
+            to values in range of 0 to 1 for HSV color model.
+            input: np.array
+        '''
+
+        match self.normalization_func:
+
+            case 'linear':
+                def func(x): return (x - np.min(input)) / \
+                    (np.max(input) - np.min(input))
+
+            case 'sigmoid':
+                def func(x): return 1 / (1 + np.exp(-x))
+
+            # case 'log':
+            #     log_input = np.log1p(input)
+            #     func = lambda x: (x - np.min(log_input)) / (np.max(log_input) - np.min(log_input))
+
+        return [func(x) for x in input]
+
+    def __vector_addition(self, data, binarization) -> list:
+
+        resultants = np.array((), dtype=np.float32)
+
+        for points, bins in zip(data, binarization):
+
+            # ignore empty lines
+            if not all(x == 0 for x in points):
+
+                # Calculate resultant vector
+                resultants = np.append(
+                    resultants,
+                    np.sum(
+                        [points[i] * np.exp(1j * self.angles[i])
+                            if bins[i] or self.whole_sum
+                            else 0
+                            for i in range(len(points))
+                         ]
+                    )
+                )
+            else:
+                resultants = np.append(resultants, (0))
+
+        return resultants
+
+    def __find_match_modality(self, sample, list) -> int:
+        for i, item in enumerate(list):
+            if np.array_equal(item, sample):
+                return i
+        return 0
+
+    def __draw_scalecircle(self, ax) -> None:
+
+        # Plot the single-unit circle
+        r = self.scalecircle
+        theta = np.linspace(0, 2*np.pi, 100)
+        ax.plot(theta, [r]*len(theta), color='black',
+                linestyle=self.scalecircle_linestyle, linewidth=self.scalecircle_linewidth, zorder=10)
+
+    def __initiate_subplot(self, ax) -> None:
+
+        # Set custom design
+        ax.set_yticklabels([])
+        ax.set_xticks(self.angles if self.labels else [])
+        ax.grid(False)
+        ax.spines['polar'].set_visible(
+            False) if not self.debug_flag else ax.spines['polar'].set_visible(True)
+        ax.patch.set_facecolor('none')
+
+    # Draw coordinate grid on the top of figure
+    # to make easier subplots alignment on devtime
+
+    def __debug_grid(self, fig, y, x) -> None:
+
+        for i in range(1, y*x+1):
+
+            ax = fig.add_subplot(y, x, i)
+
+            # Set the facecolor of the axes
+            ax.patch.set_facecolor('none')
+            ax.set_xticks([])
+            ax.set_yticks([])
+
+            for spine in ax.spines.values():
+                spine.set_edgecolor('black')
+
+    def __draw_subplot(self, ax, resultants, modality_pattern, modalities) -> None:
+
+        # for future sets calculation
+        sets_counter = [0] * 8
+
+        # Color measurement in HSV format (temporarry abandoned future)
+        # hue_array = self.__normalization(np.angle(resultants))
+        # sat_array = np.ones_like(hue_array)
+        # val_array = self.__normalization(np.abs(resultants))
+        # color = mcolors.hsv_to_rgb((hue, sat, val))
+
+        for resultant, data_row, bin_row in zip(resultants, self.data, self.binarization):
+
+            if (resultant
+                and np.array_equal(bin_row, modality_pattern) 
+                or (self.full_center 
+                    and modality_pattern == (True, True, True)
+                    and (tuple(bin_row) not in self.modality_patterns[:3] 
+                        or self.whole_sum
+                        )
+                    )                                                                                
+                ):
+
+                # defining the modality of responce to apply color and z-order
+                modality_pattern_number = self.__find_match_modality(
+                    bin_row, self.modality_patterns)
+                sets_counter[modality_pattern_number] += 1
+                color = self.colors[modality_pattern_number]
+                zorder = modality_pattern_number
+
+                ax.plot(
+                    [0, np.angle(resultant)],
+                    [0, np.abs(resultant)],
+                    zorder=zorder,
+                    marker=self.marker,
+                    linestyle=self.linestyle,
+                    linewidth=self.linewidth,
+                    color=color,
+                    alpha=self.alpha
+                )
+                if self.labels:
+                    ax.set_xticklabels(modalities)
+
+        if self.scalecircle:
+            self.__draw_scalecircle(ax)
+
+    def _make_layout(self) -> None:
+        '''
+            Make figure layout,
+            starting point of plotting
+        '''
+
+        # Defining layout
+        gs = gridspec.GridSpec(20, 20, figure=self.fig)
+        # fig.add_subplot(gs[1:11, 5:15], polar=True)
+        ax1 = self.fig.add_subplot(gs[7:17, 1:11], polar=True)
+        # fig.add_subplot(gs[7:17, 1:11], polar=True)
+        ax2 = self.fig.add_subplot(gs[1:11, 5:15], polar=True)
+        ax3 = self.fig.add_subplot(gs[7:17, 9:19], polar=True)
+        ax12 = self.fig.add_subplot(gs[4:14, 3:13], polar=True)
+        # fig.add_subplot(gs[4:14, 7:17], polar=True)
+        ax13 = self.fig.add_subplot(gs[7:17, 5:15], polar=True)
+        # fig.add_subplot(gs[7:17, 5:15], polar=True)
+        ax23 = self.fig.add_subplot(gs[4:14, 7:17], polar=True)
+        ax0 = self.fig.add_subplot(gs[5:15, 5:15], polar=True)
+        subplots = (ax1, ax2, ax3, ax12, ax13, ax23, ax0)
+
+        # calculate resultants
+        resultants = self.__vector_addition(self.data, self.binarization)
+
+        # plot each subplot
+        for ax, modality_pattern, modalities in zip(subplots, self.modality_patterns, self.modalities_array):
+            self.__initiate_subplot(ax)
+            self.__draw_subplot(ax, resultants, modality_pattern, modalities)
+
+        if self.same_scale:
+            rlim = ax0.get_xlim()
+            for ax in subplots:
+                ax.set_rlim(rlim)
+
+        # Draw coordinate grid on the top of figure
+        # to make easier subplots alignment on devtime
+        if self.debug_flag:
+            self.__debug_grid(self.fig, 20, 20)
+
+        plt.subplots_adjust(wspace=0.0, hspace=0.0)
+        plt.tight_layout()
+        plt.suptitle(self.title)
+
+
+if __name__ == '__main__':
+    print('\nThis script can be used as an imported module only\n')

DiaModality/__init__.py

@@ -0,0 +1,2 @@
+#!/usr/bin/env python
+from ._version import __version__

DiaModality/__main__.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python
+
+if __name__ == '__main__':
+    print('\nThis script can be executed as an imported module only\n')

DiaModality/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.3"

DiaModality-0.1.3.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 konung-yaropolk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

DiaModality-0.1.3.dist-info/METADATA

@@ -0,0 +1,150 @@
+Metadata-Version: 2.1
+Name: DiaModality
+Version: 0.1.3
+Summary: Tool to plot modality vector diagrams
+Author-email: konung-yaropolk <yaropolk1995@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2024 konung-yaropolk
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: Homepage, https://github.com/konung-yaropolk/DiaModality
+Project-URL: Issues, https://github.com/konung-yaropolk/DiaModality/issues
+Keywords: Visualization,Plotting,Matplotlib
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+
+# DiaModality - The Modality Diagram
+
+Simple tool to plot vector modality diagram
+
+### To install package run the command:
+```bash
+pip install diamodality
+```
+
+
+### How to use:
+See the /demo directory on Git repo or  
+create and run the following two files:
+
+---
+``generate_sample_data.py``:
+```python
+import csv
+import random
+import os
+
+num_rows = 1500
+output_file = 'modality_data.csv'
+
+# locate working directory
+script_dir = os.path.dirname(os.path.realpath(__file__))
+file_path = os.path.join(script_dir, output_file)
+
+# Open a new CSV file to write the data
+with open(file_path, mode='w', newline='') as file:
+    writer = csv.writer(file)
+
+    # Generate the data
+    signal_treshold = 1.5
+    for _ in range(num_rows):
+
+        # generate data columns:
+        col1 = random.uniform(0, 2.7)
+        col2 = random.uniform(0, 3.3)
+        col3 = random.uniform(0, 7.3)
+
+        # generate binarization columns:
+        col4 = 1 if col1 > signal_treshold else ''
+        col5 = 1 if col2 > signal_treshold else ''
+        col6 = 1 if col3 > signal_treshold else ''
+
+        writer.writerow([col1, col2, col3, col4, col5, col6])
+
+```
+
+
+---
+``plot_sample_data.py``:
+```python
+import DiaModality.CsvParser as csv
+import DiaModality.ModalityPlot as plt
+import os
+
+# input file:
+files = 'modality_data.csv'
+
+# Get full path of input files
+script_dir = os.path.dirname(os.path.realpath(__file__))
+file_path = os.path.join(script_dir, file)
+
+# Parse data from csv file
+new_csv = csv.LoadCsv(file_path)
+data, binarization = new_csv.ParseCsv(3, 3)
+
+# Make figure:
+plot = plt.ModalityPlot(
+    data,
+    binarization,
+    modalities=['Set 1', 'Set 2', 'Set 3'],
+    angles=[210, 90, 330],
+    labels=False,
+    scalecircle=0.5,           # Scale circle radius
+    scalecircle_linestyle=':',
+    scalecircle_linewidth=0.75,
+    marker='',                 # vector endpoints marker
+    linestyle='-',
+    linewidth=0.5,
+    alpha=0.5,
+    same_scale=False,          # Draw all the subplots in the same scale
+    full_center=True,          # Draw all vectors in the central subplot, else draw trimodal vectors only
+    whole_sum=True,            # Calculate all three modality vectors despite binarization
+    figsize=(10, 10),
+    title='Modality Diagram Example',
+    colors=(
+        'tab:green',   # Set 1 color
+        'navy',        # Set 2 color
+        'tab:red',     # Set 3 color
+        '#1E88E5',     # Sets 1 & 2 intersection color
+        '#FF9933',     # Sets 1 & 3 intersection color
+        '#9900FF',     # Sets 2 & 3 intersection color
+        'black',       # All sets   intersection color
+    ),      
+)
+
+plot.save(file_path, type='png', transparent=False)
+plot.show()
+```
+
+Source page: 
+https://github.com/konung-yaropolk/DiaModality
+
+
+![modality_data csv](https://github.com/user-attachments/assets/eb77b4d7-281f-45b0-a5ce-4c2442fc9a75)

DiaModality-0.1.3.dist-info/RECORD

@@ -0,0 +1,10 @@
+DiaModality/CsvParser.py,sha256=7Obsb4N1rKbh61lW14HbQ1I2wgp0WWDZBCLn3okGkKE,2388
+DiaModality/ModalityPlot.py,sha256=_YSwSFvBB6KzeweZWsz7LwCeQBVaecKMeUgWA7dHMO4,12043
+DiaModality/__init__.py,sha256=dG2uQjZL0lNFRoeQL_znkCWNDwVqzLdUc6NwTAMLOV4,58
+DiaModality/__main__.py,sha256=fuCOdcGCsOis-_tmgYEsOEINKOfDOf2wrHfX7DBiRRY,126
+DiaModality/_version.py,sha256=LPNaKUFe5S0lxcbXP4IcviKz02tUsjRUDAJch2OV7IE,23
+DiaModality-0.1.3.dist-info/LICENSE,sha256=xj_-qiB7H9szm74jCUlWpSLmHozF0k-FWpACE-AaouI,1091
+DiaModality-0.1.3.dist-info/METADATA,sha256=LF3LkMnEMfHfAxijlT-29V6eVquMGuoDzYmdpukvXko,5063
+DiaModality-0.1.3.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+DiaModality-0.1.3.dist-info/top_level.txt,sha256=3fHizr4llS7jJzpwH6BSm-9nHZy2nsYrtcVcPt3yW5M,12
+DiaModality-0.1.3.dist-info/RECORD,,

DiaModality-0.1.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

DiaModality-0.1.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+DiaModality