diff --git a/README.md b/README.md
index a767ed29d321376d4049f7081c43b544dd26b4f8..8f008d44ab7c7e530e27684fab897458afcb537e 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,31 @@
-# CParada
+# Mechanical feedback defines organizing centers to drive digit emergence
 
+## Description
+
+This repository contain code used in the **Mechanical feedback defines organizing centers to drive digit emergence** study.
+It is an extention of the [(Durande et. al., 2019)](https://github.com/mdurande/coarse-grained-anisotropy-and-size-using-FFT) framework to incorporate spatiality in the anisotropy (orientation and strain) of cells.
+This is applied for both study of cell anysotropy in Sox9(+) areas against Sox9(-) areas of the digit during formation in Wnt5a-/- and Ctrl individuals.
+
+![image](./figure/description.png)
+
+## Usage
+
+The matlab script (2019b) take as input the a list of processed data from Durande's framework and display simplistic UI for region delimitation.
+The output is a formated CSV file containing the Orientation, Shear, and Intensity per region of tissues.
+
+The CSV file is the direct input for the notebook script to plots orientation histograms and average distribution along the Proximal-Distal axis.
+
+
+```
+conda create -n project python=3.9
+conda activate project
+pip install -r requirements.txt
+```
+
+## Acknoledgement
+
+If using or relying on this work, please cite the **Mechanical feedback defines organizing centers to drive digit emergence** paper.
+
+```
+// todo: add citation bib
+```
diff --git a/figure/description.png b/figure/description.png
new file mode 100644
index 0000000000000000000000000000000000000000..838289850c5b72bcc9d14f7b670ae48deb24513d
Binary files /dev/null and b/figure/description.png differ
diff --git a/matlab_script/QuantLib/Analyse.m b/matlab_script/QuantLib/Analyse.m
new file mode 100755
index 0000000000000000000000000000000000000000..5bb421b71d228583cd9e33b94b8b774189bff6fc
--- /dev/null
+++ b/matlab_script/QuantLib/Analyse.m
@@ -0,0 +1,44 @@
+function Analyse(folder, quantities, phenotype)
+% Quantification extract quantities and weight from processed folder
+%   and return cropped area to compared against.
+
+%% Extract list of subfolders to process
+listing = dir(folder);
+listing(strncmp({listing.name}, '.', 1)) = [];
+Folders = listing([listing.isdir]);
+
+%% Process all animals
+for t = 1:numel(phenotype)
+    TF = contains({Folders.name}, phenotype{t});
+    subFolders = Folders(TF);
+    for f = 1:numel(subFolders)
+        folder_name = [subFolders(f).folder filesep subFolders(f).name];
+        if ~exist([folder_name filesep 'QuantifBackup.mat'])
+            Quantification(folder_name, quantities, phenotype{t});
+        end
+    end
+end
+
+%% Reload backup
+qCount = 1;
+for t = 1:numel(phenotype)
+    TF = contains({Folders.name}, phenotype{t});
+    subFolders = Folders(TF);
+    for f = 1:numel(subFolders)
+        folder_name = [subFolders(f).folder filesep subFolders(f).name];
+        BackupList(qCount) = load([folder_name filesep 'QuantifBackup.mat']);
+        qCount = qCount + 1;
+    end
+end
+
+%% quantification reshape
+quantifications = GetQuantities(BackupList);
+writetable(quantifications, [folder filesep 'globalQuantification.csv']);
+
+% % Plot analysis
+% for q=1:numel(quantities)
+%     PlotValueAlongAxis(BackupList, phenotype, folder, quantities{q}, true);
+%     PlotValueHistogram(BackupList, phenotype, folder, quantities{q}, true);
+% end
+
+end
\ No newline at end of file
diff --git a/matlab_script/QuantLib/ComputeIntensity.m b/matlab_script/QuantLib/ComputeIntensity.m
new file mode 100755
index 0000000000000000000000000000000000000000..c37b232d0e8c11964614105a68983f819e027415
--- /dev/null
+++ b/matlab_script/QuantLib/ComputeIntensity.m
@@ -0,0 +1,26 @@
+function Results = ComputeIntensity(image, Results, boxsize)
+
+% image = double(imread('Z:\SRigaud\PKhalilian\Anisotropy\sagitarial_d12.5\wt2_sg\MAX_C3-wt_4x4_40x_z1_A2_x2 _3_long_Stitch-1.tif'));
+% load('Z:\SRigaud\PKhalilian\Anisotropy\sagitarial_d12.5\wt2_sg\Results.mat');
+% boxsize=128;
+
+imageSize = size(image);
+boxArea = (boxsize+1)*(boxsize+1);
+gridPixelLs = NaN(length(Results.Posi), boxArea);
+for b = 1:length(Results.Posi)
+   ulc = Results.Posi(b,:);
+   [X, Y] = meshgrid(ulc(1):ulc(1)+boxsize,ulc(2):ulc(2)+boxsize);
+   coord = sub2ind(imageSize,Y,X);
+   gridPixelLs(b, :) = coord(:)';
+end
+
+
+% normalise between 0-1
+image = double(image);
+image = (image - nanmin(image(:))) * (1 ./ (nanmax(image(:)) - nanmin(image(:))));
+intensityDistribution = sum(image(gridPixelLs),2) / boxArea; % 1.0
+intensityDistribution = reshape(intensityDistribution, Results.numY, Results.numX);
+
+Results.im_regav.Intensity = reshape(intensityDistribution, [1, Results.numY, Results.numX]);
+
+end
diff --git a/matlab_script/QuantLib/ComputeWeight.m b/matlab_script/QuantLib/ComputeWeight.m
new file mode 100755
index 0000000000000000000000000000000000000000..98016305c5fbcc4e7cf285a5e9f32db589d9c621
--- /dev/null
+++ b/matlab_script/QuantLib/ComputeWeight.m
@@ -0,0 +1,39 @@
+function [w1, w2, w3] = ComputeWeight(data, roi1, roi2)
+% ComputeWeight Using grid information and both roi, we compute weight (0-1)
+%   for each compartment of the grid
+%
+
+% output container initialisation
+w1 = zeros(1, data.numY, data.numX);
+w2 = zeros(1, data.numY, data.numX);
+w3 = zeros(1, data.numY, data.numX);
+
+roi3 = or(roi1, roi2);
+
+% grid box size
+dS = median(abs(data.Posi(1:data.numY-1, 2) - data.Posi(2:data.numY, 2)));
+
+% loop on each grid box
+for b = 1:data.regl
+    % get coordinate of the grid in the data
+    [ny, nx] = ind2sub([data.numY data.numX], b);
+    
+    % get the box coordinatess
+    x1 = round(data.Posi(b, 1));
+    y1 = round(data.Posi(b, 2));
+    [X, Y] = meshgrid(x1:x1+dS, y1:y1+dS);
+    coord = sub2ind(size(roi1), Y, X);
+    
+    % get roi values
+    crop_roi1 = roi1(coord);
+    crop_roi2 = roi2(coord);
+    crop_roi3 = roi3(coord);
+    
+    % compute weight
+    w1(1, ny, nx) = sum(crop_roi1(:)) / numel(crop_roi1(:));
+    w2(1, ny, nx) = sum(crop_roi2(:)) / numel(crop_roi2(:));
+    w3(1, ny, nx) = sum(crop_roi3(:)) / numel(crop_roi3(:));
+end
+
+end
+
diff --git a/matlab_script/QuantLib/CornerToGridData.m b/matlab_script/QuantLib/CornerToGridData.m
new file mode 100755
index 0000000000000000000000000000000000000000..f86f77137ebec0e557e53270a25e6a8558d5ef29
--- /dev/null
+++ b/matlab_script/QuantLib/CornerToGridData.m
@@ -0,0 +1,33 @@
+function [crop_values, crop_weight, full_weight] = CornerToGridData(data, weight, corners, field)
+% CornerToGridData Use corner coordinates to get corresponding grid values
+% and weight of a specific field
+%   
+
+% ulc = [250 300];
+% brc = [600 1000];
+% field = "phi";
+% 
+% path = "/home/stephane/Documents/Projects/PKhalilian/Anisotropy/transversal/wt1_tr";
+% load(path + filesep + "Results.mat");
+% data = Results;
+% 
+% weight = ones(1,data.numY,data.numX);
+
+ulc = corners(:, 1, :);
+brc = corners(:, 2, :);
+
+% get linear index of boxes of interest
+grid_idx_y = data.Posi(:,2) > ulc(1) & data.Posi(:,2) < brc(1);
+grid_idx_x = data.Posi(:,1) > ulc(2) & data.Posi(:,1) < brc(2);
+grid_idx = find(grid_idx_x & grid_idx_y);
+[y, x] = ind2sub([data.numY data.numX], grid_idx);
+
+values = data.im_regav.(field);
+crop_values = squeeze(values(:, min(y):max(y), min(x):max(x)));
+crop_weight = squeeze(weight(:, min(y):max(y), min(x):max(x)));
+
+full_weight = zeros(size(squeeze(weight)));
+full_weight(min(y):max(y), min(x):max(x)) = squeeze(weight(:, min(y):max(y), min(x):max(x)));
+
+end
+
diff --git a/matlab_script/QuantLib/GetQuantities.m b/matlab_script/QuantLib/GetQuantities.m
new file mode 100755
index 0000000000000000000000000000000000000000..8b653e2775e80934c63e3b3b24dbab6e84115239
--- /dev/null
+++ b/matlab_script/QuantLib/GetQuantities.m
@@ -0,0 +1,76 @@
+function quantifications = GetQuantities(BackupList)
+
+qnames = {'angS' ; 'S' ; 'Intensity'};
+anames = {'area1' ; 'area2'; 'area3'};
+
+vnames = {'Type';'Animal';'Area';'ValueType';'Distance';'Value';'Weight'};
+Phenotype = cell(1,0);
+Animal = cell(1,0);
+Area = cell(1,0);
+ValueType = cell(1,0);
+Distance = [];
+Value = [];
+Weight = [];
+
+Intensity = [];
+Angle = [];
+Shear = [];
+SymAngle = [];
+
+for b = 1:numel(BackupList)
+    currentBkp = BackupList(b).QuantifBackup;
+    for a = 1:numel(anames)
+        for q = 1:numel(qnames)
+            currentArea = anames{a};
+            currentVal = qnames{q};
+            
+            qvalues = currentBkp.(currentArea).(currentVal);
+            
+            
+            
+            if strcmp(currentVal, 'Intensity')
+                Intensity = [Intensity; qvalues(:)];
+            end
+            if strcmp(currentVal, 'angS')
+                qvalues = qvalues + (pi/2);
+                Angle = [Angle; qvalues(:)];
+                qvalues(qvalues>(pi/2)) = (pi/2) - (qvalues(qvalues>(pi/2)) - (pi/2));
+                SymAngle = [SymAngle; qvalues(:)];
+            end
+            if strcmp(currentVal, 'S')
+                qvalues = abs(qvalues);
+                Shear = [Shear; qvalues(:)];
+            end
+            
+            
+        end
+        
+        qweigth = currentBkp.(currentArea).weight;
+        
+        [h, w] = size(qweigth);
+        [~, YY] = meshgrid(1:w,1:h);
+        
+        Distance = [Distance; YY(:)];
+        Weight = [Weight; qweigth(:)];
+        
+        tmp = cell(1, length(qvalues(:)));
+        tmp(:) = {num2str(a)};
+        Area = [Area; tmp(:)];
+        tmp(:) = {currentBkp.phenotype};
+        Phenotype = [Phenotype; tmp(:)];
+        tmp(:) = {currentBkp.name};
+        Animal = [Animal; tmp(:)];
+    end
+end
+
+length(Phenotype)
+length(Animal)
+length(Area)
+length(Distance)
+length(Intensity)
+length(Angle)
+length(SymAngle)
+length(Shear)
+length(Weight)
+
+quantifications = table(Phenotype, Animal, Area, Distance, Intensity, Angle, SymAngle, Shear, Weight);
diff --git a/matlab_script/QuantLib/GetRoI.m b/matlab_script/QuantLib/GetRoI.m
new file mode 100755
index 0000000000000000000000000000000000000000..1fa4a3f38bcc4005b26998176e6cade4ff2f2c5b
--- /dev/null
+++ b/matlab_script/QuantLib/GetRoI.m
@@ -0,0 +1,41 @@
+function [roi_ph, roi_sox] = GetRoI(ph, sox)
+% GetRoI compute and return binary map of phaloidine and sox9 localisation
+%   in image.
+%   ph, sox, respectively phaloiding and sox9 data.
+%
+
+ph = double(ph);
+sox = double(sox);
+
+% normalise [0-1] and convert to double
+roi_ph = (ph - min(ph(:))) / (max(ph(:)) - min(ph(:)));
+roi_sox = (sox - min(sox(:))) / (max(sox(:)) - min(sox(:)));
+
+% get roi of sox9
+sigma = 25;
+h = fspecial('gaussian', round(3*sigma), sigma);
+roi_sox = imfilter(roi_sox, h, 'same');
+treshold = graythresh(roi_sox);
+roi_sox = imbinarize(roi_sox, treshold);
+
+CC = bwconncomp(roi_sox);
+numPixels = cellfun(@numel,CC.PixelIdxList);
+[biggest, idx] = max(numPixels);
+roi_sox = zeros(size(roi_sox));
+roi_sox(CC.PixelIdxList{idx}) = 1;
+roi_sox = bwconvhull(roi_sox);
+
+% get roi of ph
+radius = 50;
+roi_ph = medfilt2(roi_ph, [3 3]);
+roi_ph(roi_ph > 0) = 1;
+roi_ph = imfill(roi_ph, 'holes');
+roi_ph = imerode(roi_ph, strel('disk', radius));
+
+roi_ph = roi_ph - roi_sox;
+
+double(roi_ph);
+double(roi_sox);
+
+end
+
diff --git a/matlab_script/QuantLib/PlotValueAlongAxis.m b/matlab_script/QuantLib/PlotValueAlongAxis.m
new file mode 100755
index 0000000000000000000000000000000000000000..c452aca19d41f63c70635f031b2c11556390479b
--- /dev/null
+++ b/matlab_script/QuantLib/PlotValueAlongAxis.m
@@ -0,0 +1,99 @@
+function PlotValueAlongAxis(BackupList, phenotype, folder, quantity, csv)
+
+colors = [[128 193 219]./255 ; [243 169 114]./255];
+boxsize = (128*0.5) * 0.313;
+tau1 = 0.25;
+tau2 = -0.1;
+
+vnames = {'Type';'Animal';'ValueType';'Distance';'Value'};
+quantifications = table('Size',[0 5],'VariableTypes', {'string';'string'; 'string'; 'double'; 'double'},'VariableNames',vnames);
+
+Phenotype = {};
+Animal = {};
+ValueType = {};
+Distance = [];
+Value = [];
+
+f1=figure();
+for f = 1:numel(phenotype)
+    
+    projValue = nan(50, 100);
+    maximum_size = -1;
+    count = 1;
+    
+    for b = 1:numel(BackupList)
+        
+        
+
+        if strcmp(BackupList(b).QuantifBackup.phenotype, phenotype(f))
+            
+
+            
+            qvalues = BackupList(b).QuantifBackup.area3.(quantity);
+            if strcmp(quantity, 'angS')
+                qvalues = qvalues + (pi/2);
+                qvalues(BackupList(b).QuantifBackup.area3.S>tau2) = nan;
+                qvalues(qvalues>(pi/2)) = (pi/2) - (qvalues(qvalues>(pi/2)) - (pi/2));
+                qvalues = rad2deg(qvalues);
+            end
+            if strcmp(quantity, 'S')
+                qvalues = abs(qvalues);
+            end
+            qweigth = BackupList(b).QuantifBackup.area3.weight;
+            qvalues(qweigth<tau1) = nan;
+            values_size = size(qvalues, 1);
+            for i=1:values_size
+                avg_values(i) = nansum(qvalues(i,:) .* qweigth(i,:)) / sum(~isnan(qvalues(i,:)));
+            end
+            projValue(count, 1:values_size) = avg_values;
+            maximum_size = max(maximum_size, values_size);
+            count = count + 1;
+            clear( 'qvalues', 'qweigth', 'avg_values');
+            
+            Phenotype = {Phenotype ; BackupList(b).QuantifBackup.phenotype};
+            Animal = {Animal ; BackupList(b).QuantifBackup.name};
+            ValueType = {ValueType ; quantity};
+            Distance = [Distance ];
+            Value = [Value ];
+        end
+        
+    end % backup loop
+    
+    
+    
+    xvals = [0:maximum_size-2] * boxsize;
+    qplot = projValue(1:count-1,1:maximum_size-1);
+    
+    hold on
+    options.handle=f1;
+    options.color_area = colors(f,:);
+    options.color_line = colors(f,:);
+    options.alpha = 0.5;
+    options.line_width = 2;
+    options.error = 'std';
+    options.x_axis = xvals;
+    plot_areaerrorbar(qplot, options)
+    hold off
+    
+    if csv
+        csvwrite([folder filesep quantity '_' phenotype{f} '_D-P_axis.csv'], qplot)
+    end
+    
+end % phenotype loop
+
+if strcmp(quantity, 'angS')
+    ylim([0 90])
+end
+% xlim([0 500])
+
+
+legend(phenotype)
+xlabel("D-P axis length (um)")
+ylabel(quantity)
+title([quantity ' D-P Axis'])
+saveas(f1, [folder filesep quantity '_D-P_Axis.png']);
+close(f1);
+
+
+end
+
diff --git a/matlab_script/QuantLib/PlotValueHistogram.m b/matlab_script/QuantLib/PlotValueHistogram.m
new file mode 100755
index 0000000000000000000000000000000000000000..44995cfc7956031814a97057b8ed5f3863770668
--- /dev/null
+++ b/matlab_script/QuantLib/PlotValueHistogram.m
@@ -0,0 +1,75 @@
+function PlotValueHistogram(BackupList, phenotype, folder, quantity, csv)
+
+colors = [[128 193 219]./255 ; [243 169 114]./255];
+boxsize = (128*0.5) * 0.313;
+
+tau1 = 0.25;
+tau2 = -0.1;
+
+for f = 1:numel(phenotype)
+    
+    qmerge_a1 = [];
+    qmerge_a2 = [];
+    
+    for b = 1:numel(BackupList)
+        
+        if strcmp(BackupList(b).QuantifBackup.phenotype, phenotype(f))
+            qvalues_a1 = BackupList(b).QuantifBackup.area1.(quantity);
+            qvalues_a2 = BackupList(b).QuantifBackup.area2.(quantity);
+            qweigth_a1 = BackupList(b).QuantifBackup.area1.weight;
+            qweigth_a2 = BackupList(b).QuantifBackup.area2.weight;
+            
+            if strcmp(quantity, 'angS')
+                qvalues_a1 = qvalues_a1 + (pi/2);
+                qvalues_a2 = qvalues_a2 + (pi/2);
+                qvalues_a1(BackupList(b).QuantifBackup.area1.S>tau2) = nan;
+                qvalues_a2(BackupList(b).QuantifBackup.area1.S>tau2) = nan;
+            end
+            if strcmp(quantity, 'S')
+                qvalues_a1 = abs(qvalues_a1);
+                qvalues_a2 = abs(qvalues_a2);
+            end
+            
+            qvalues_a1(qweigth_a1<tau1) = nan;
+            qvalues_a2(qweigth_a2<tau1) = nan;
+            
+            qmerge_a1 = [qmerge_a1 ; qvalues_a1(:)];
+            qmerge_a2 = [qmerge_a2 ; qvalues_a2(:)];
+        end
+        
+    end % end backup
+    
+    
+    f1 = figure();
+    if strcmp(quantity, 'angS')
+        polarhistogram(qmerge_a1, [0:(pi/20):pi],  'FaceColor', colors(f,:), 'FaceAlpha',.3);
+    else
+        histogram(qmerge_a1, [0:(1/20):1],  'FaceColor', colors(f,:), 'FaceAlpha',.3);
+    end
+    title(['Histogram ' quantity ' ' phenotype{f} ' Area 1'])
+    saveas(f1, [folder filesep 'histogram_' quantity '_' phenotype{f} '_Area=1.png']);
+    close(f1);
+    if csv
+        csvwrite([folder filesep 'histogram_' quantity '_' phenotype{f} '_Area=1.csv'], qmerge_a1);
+    end
+    
+    f1 = figure();
+    if strcmp(quantity, 'angS')
+        polarhistogram(qmerge_a2, [0:(pi/20):pi],  'FaceColor', colors(f,:), 'FaceAlpha',.3);
+    else
+        histogram(qmerge_a2, [0:(1/20):1],  'FaceColor', colors(f,:), 'FaceAlpha',.3);
+    end
+    title(['Histogram ' quantity ' ' phenotype{f} ' Area 2'])
+    saveas(f1, [folder filesep 'histogram_' quantity '_' phenotype{f} '_Area=2.png']);
+    close(f1);
+    if csv
+        csvwrite([folder filesep 'histogram_' quantity '_' phenotype{f} '_Area=2.csv'], qmerge_a2);
+    end
+    
+end % phenotype
+
+
+
+
+
+end
\ No newline at end of file
diff --git a/matlab_script/QuantLib/Quantification.m b/matlab_script/QuantLib/Quantification.m
new file mode 100755
index 0000000000000000000000000000000000000000..bc309cf931ff2f0c74f48d3396ca9ed66b3b5f35
--- /dev/null
+++ b/matlab_script/QuantLib/Quantification.m
@@ -0,0 +1,91 @@
+function QuantifBackup = Quantification(folder, field_list, phenotype)
+% Quantification extract quantities and weight from processed folder
+%   and return cropped area to compared against.
+
+% folder = 'E:\UserData\srigaud\script\wt1_tr';
+% field_list = {"phi"; "angS"};
+
+% initialise output
+QuantifBackup = struct();
+
+%% clean and select files that are going to be processed
+[~,animal,~] = fileparts(folder);
+listing = dir(folder);
+mat_file_ind = cellfun(@(x)( ~isempty(x) ), regexpi({listing.name}, 'Results.mat'));
+ph_file_ind = cellfun(@(x)( ~isempty(x) ), regexpi({listing.name}, 'C4'));
+sox_file_ind = cellfun(@(x)( ~isempty(x) ), regexpi({listing.name}, 'C3'));
+
+%% load data in workspace for processing
+load([folder filesep listing(mat_file_ind).name]);
+phal = imread([folder filesep listing(ph_file_ind).name]);
+sox9 = imread([folder filesep listing(sox_file_ind).name]);
+
+%% compute region of interest for both signal
+[roi_phal, roi_sox9] = GetRoI(phal, sox9);
+
+imwrite(uint8(roi_phal),[folder filesep 'roi_phal_image.png']);
+imwrite(uint8(roi_sox9),[folder filesep 'roi_sox9_image.png']);
+
+%% user input for area definition
+img = cat(3, imadjust(phal), imadjust(sox9), zeros(size(phal)));
+[corners, figHandler] = ZoneSelectionInterface(img, roi_phal, Results);
+saveas(figHandler, [folder filesep 'QuantifSelectedArea.png'])
+close(figHandler);
+
+%% compute weight from region of interest and grid configuration
+[w1_phal, w2_sox9, w3_all] = ComputeWeight(Results, roi_phal, roi_sox9);
+
+imwrite((squeeze(w1_phal)),[folder filesep 'weight_phal_image.png']);
+imwrite((squeeze(w2_sox9)),[folder filesep 'weight_sox9_image.png']);
+imwrite((squeeze(w3_all)),[folder filesep 'weight_all_image.png']);
+
+%% compute intensity
+Results = ComputeIntensity(sox9, Results, 128);
+
+
+%% extract values and weights and fill struct
+QuantifBackup.corners = corners;
+QuantifBackup.roi_phal = roi_phal;
+QuantifBackup.roi_sox9 = roi_sox9;
+QuantifBackup.phenotype = phenotype;
+QuantifBackup.name = animal;
+
+for n=1:numel(field_list)
+    % using area information, crop value and weight from analysis
+    [crop_values_area1, crop_weight_area1, full_w_1] = CornerToGridData(Results, w1_phal, corners(1,:,:), field_list{n});
+    [crop_values_area2, crop_weight_area2, full_w_2] = CornerToGridData(Results, w2_sox9, corners(2,:,:), field_list{n});
+    [crop_values_area3, crop_weight_area3, full_w_3] = CornerToGridData(Results, w3_all, corners(3,:,:), field_list{n});
+
+
+    % store in struct for futur plotting
+    QuantifBackup.area1.weight = crop_weight_area1;
+    QuantifBackup.area1.(field_list{n}) = crop_values_area1;
+    QuantifBackup.area2.weight = crop_weight_area2;
+    QuantifBackup.area2.(field_list{n}) = crop_values_area2;
+    QuantifBackup.area3.weight = crop_weight_area3;
+    QuantifBackup.area3.(field_list{n}) = crop_values_area3;
+end
+
+    imwrite((squeeze(full_w_1)),[folder filesep 'weight_phal_image.png']);
+    imwrite((squeeze(full_w_2)),[folder filesep 'weight_sox9_image.png']);
+    imwrite((squeeze(full_w_3)),[folder filesep 'weight_all_image.png']);
+    
+    load([folder filesep 'Results.mat']);
+    gridout = zeros(size(phal));
+    wsize = 64;
+    for r = 1:length(Results.Posi)
+        yulc = Results.Posi(r, 2);
+        xulc = Results.Posi(r, 1);
+        gridout(yulc,xulc:xulc+wsize) = 255;
+        gridout(yulc+wsize,xulc:xulc+wsize) = 255;
+        gridout(yulc:yulc+wsize,xulc) = 255;
+        gridout(yulc:yulc+wsize,xulc+wsize) = 255;
+    end
+    imwrite(gridout,[folder filesep 'grid_image.png']);
+    
+
+%% save output
+save([folder filesep 'QuantifBackup.mat'], 'QuantifBackup')
+
+end
+
diff --git a/matlab_script/QuantLib/ZoneSelectionInterface.m b/matlab_script/QuantLib/ZoneSelectionInterface.m
new file mode 100755
index 0000000000000000000000000000000000000000..82e2cc03615d1b26d5b9804f91010e196a45dd54
--- /dev/null
+++ b/matlab_script/QuantLib/ZoneSelectionInterface.m
@@ -0,0 +1,125 @@
+function [corners, interfaceHandle] = ZoneSelectionInterface(img, roi, data)
+%UNTITLED4 Summary of this function goes here
+%   Detailed explanation goes here
+
+% path = "/home/stephane/Documents/Projects/PKhalilian/Anisotropy/transversal/wt1_tr";
+% a = imread(path + filesep +"C4-control_sox9_phalloidin_3x3_1x_b2_overlapping_Image_21_Stitch.tif");
+% b = imread(path + filesep +"C2-control_sox9_phalloidin_3x3_1x_b2_overlapping_Image_21_Stitch.tif");
+% img = cat(3, a, b, zeros(size(a)));
+%
+% load(path + filesep + "Results.mat");
+% data = Results;
+
+% initialisation
+corners = nan(2, 2, 2);
+
+% visualisation interface
+screenSize = get(0, 'ScreenSize');
+Left = 5;
+Bottom = 45;
+Width = screenSize(3)/2;
+Height = screenSize(4) - 126;
+interfaceHandle = figure('Name','Define Areas to Analyse.');
+set(interfaceHandle, 'Units', 'pixels');
+set(interfaceHandle, 'WindowStyle', 'modal');
+set(interfaceHandle, 'Position', [Left Bottom Width Height]);
+
+Areas.roi = roi;
+Areas.show = true;
+
+% zone managment loop
+zone = 1;
+while zone < 3
+    % update display with text description and current selected zone and
+    % roi and other stuff
+    UpdateDisplay(img, corners, zone, Areas);
+    set(interfaceHandle, 'Position', [Left Bottom Width Height]);
+    
+    % action managment loop
+    clicks = 1;
+    while clicks < 3
+        % Get graphic input action
+        try
+            [xi, yi, buttemp] = ginputWhite(1);
+        catch err
+            if strcmp(err.identifier,'MATLAB:ginput:FigureDeletionPause')
+                disp(err.identifier); % other error
+            end
+            return;
+        end
+        % Input action managment
+        switch buttemp
+            case 1 % Mouse-L-Click : select a cell
+                corners(zone, clicks, :) = [round(yi) round(xi)];
+                clicks = clicks + 1;
+            case 9 % tab
+                Areas.roi = ~Areas.roi;
+            case 27 % esc : exit interface
+                button = questdlg('Do you want to exit the interface?','Exit','Yes','No','Yes');
+                if strcmp(button, 'Yes')
+                    return
+                end
+        end % end input managment
+        UpdateDisplay(img, corners, zone, Areas);
+    end % end clicks loop
+    
+    % User zone validation
+    if zone == 2
+        button = questdlg('Continue with those Areas?','Area validation','Yes','No','Yes');
+        if strcmp(button, 'No')
+            corners(:, :, :) = nan;
+            zone = 0;
+        end
+    end
+    
+    % loop increment
+    zone = zone + 1;
+end % end zone loop
+
+UpdateDisplay(img, corners, [], Areas);
+corners(3,1,1) = min(corners(1:2,1,1));
+corners(3,1,2) = min(corners(1:2,1,2));
+corners(3,2,1) = max(corners(1:2,2,1));
+corners(3,2,2) = max(corners(1:2,2,2));
+% all should be good
+end
+
+function UpdateDisplay(img, corners, zone, Areas)
+% reset display
+cla reset;
+
+% plot background image
+imshow(img, [], 'Border', 'tight');
+
+if Areas.show
+    hold on
+    h = imshow(Areas.roi);
+    set(h, 'AlphaData', ones(size(Areas.roi))*0.5);
+    hold off
+end
+
+% plot text on upper left corner of the image for legend and info
+if ~isempty(zone)
+    hold on
+    text(15, 15, ['Define corners for area #' num2str(zone)], "color", "yellow", "FontSize", 18, 'FontWeight','bold')
+    hold off
+end
+
+% plot all current clicks with yellow markers
+hold on
+plot(corners(:,:,2), corners(:,:,1), '+y', "markersize", 10);
+hold off
+
+% plot area if both corner are defined
+for z = 1:2
+    if all(~isnan(corners(z, :)))
+        x_list = [corners(z, 1, 2) corners(z, 2, 2) corners(z, 2, 2) corners(z, 1, 2) corners(z, 1, 2)];
+        y_list = [corners(z, 1, 1) corners(z, 1, 1) corners(z, 2, 1) corners(z, 2, 1) corners(z, 1, 1)];
+        hold on
+        plot(x_list, y_list, '-c', 'linewidth', 2);
+        text(round(mean(x_list(1:end-1))) - 50, round(mean(y_list(1:end-1))), ['Area = ' num2str(z)], "color", "cyan", "FontSize", 14, 'FontWeight','bold')
+        hold off
+    end
+end
+
+end
diff --git a/matlab_script/QuantLib/ginputWhite.m b/matlab_script/QuantLib/ginputWhite.m
new file mode 100755
index 0000000000000000000000000000000000000000..5aac142b7f00bc40ff0497ca9996ed210e2e5f67
--- /dev/null
+++ b/matlab_script/QuantLib/ginputWhite.m
@@ -0,0 +1,293 @@
+function [out1,out2,out3] = ginput(arg1)
+%GINPUT Graphical input from mouse.
+%   [X,Y] = GINPUT(N) gets N points from the current axes and returns
+%   the X- and Y-coordinates in length N vectors X and Y.  The cursor
+%   can be positioned using a mouse.  Data points are entered by pressing
+%   a mouse button or any key on the keyboard except carriage return,
+%   which terminates the input before N points are entered.
+%
+%   [X,Y] = GINPUT gathers an unlimited number of points until the
+%   return key is pressed.
+%
+%   [X,Y,BUTTON] = GINPUT(N) returns a third result, BUTTON, that
+%   contains a vector of integers specifying which mouse button was
+%   used (1,2,3 from left) or ASCII numbers if a key on the keyboard
+%   was used.
+%
+%   Examples:
+%       [x,y] = ginput;
+%
+%       [x,y] = ginput(5);
+%
+%       [x, y, button] = ginput(1);
+%
+%   See also GTEXT, WAITFORBUTTONPRESS.
+
+%   Copyright 1984-2015 The MathWorks, Inc.
+
+out1 = []; out2 = []; out3 = []; y = [];
+
+if ~matlab.ui.internal.isFigureShowEnabled
+    error(message('MATLAB:hg:NoDisplayNoFigureSupport', 'ginput'))
+end
+    
+    % Check Inputs
+    if nargin == 0
+        how_many = -1;
+        b = [];
+    else
+        how_many = arg1;
+        b = [];
+        if  ~isPositiveScalarIntegerNumber(how_many) 
+            error(message('MATLAB:ginput:NeedPositiveInt'))
+        end
+        if how_many == 0
+            % If input argument is equal to zero points,
+            % give a warning and return empty for the outputs.            
+            warning (message('MATLAB:ginput:InputArgumentZero'));
+        end
+    end
+    
+    % Get figure
+    fig = gcf;
+    drawnow;
+    figure(gcf);
+    
+    % Make sure the figure has an axes
+    gca(fig);    
+    
+    % Setup the figure to disable interactive modes and activate pointers. 
+    initialState = setupFcn(fig);
+    
+    % onCleanup object to restore everything to original state in event of
+    % completion, closing of figure errors or ctrl+c. 
+    c = onCleanup(@() restoreFcn(initialState));
+    
+    drawnow
+    char = 0;
+    
+    while how_many ~= 0
+        waserr = 0;
+        try
+            keydown = wfbp;
+        catch %#ok<CTCH>
+            waserr = 1;
+        end
+        if(waserr == 1)
+            if(ishghandle(fig))
+                cleanup(c);
+                error(message('MATLAB:ginput:Interrupted'));
+            else
+                cleanup(c);
+                error(message('MATLAB:ginput:FigureDeletionPause'));
+            end
+        end
+        % g467403 - ginput failed to discern clicks/keypresses on the figure it was
+        % registered to operate on and any other open figures whose handle
+        % visibility were set to off
+        figchildren = allchild(0);
+        if ~isempty(figchildren)
+            ptr_fig = figchildren(1);
+        else
+            error(message('MATLAB:ginput:FigureUnavailable'));
+        end
+        %         old code -> ptr_fig = get(0,'CurrentFigure'); Fails when the
+        %         clicked figure has handlevisibility set to callback
+        if(ptr_fig == fig)
+            if keydown
+                char = get(fig, 'CurrentCharacter');
+                button = abs(get(fig, 'CurrentCharacter'));
+            else
+                button = get(fig, 'SelectionType');
+                if strcmp(button,'open')
+                    button = 1;
+                elseif strcmp(button,'normal')
+                    button = 1;
+                elseif strcmp(button,'extend')
+                    button = 2;
+                elseif strcmp(button,'alt')
+                    button = 3;
+                else
+                    error(message('MATLAB:ginput:InvalidSelection'))
+                end
+            end
+            
+            if(char == 13) % & how_many ~= 0)
+                % if the return key was pressed, char will == 13,
+                % and that's our signal to break out of here whether
+                % or not we have collected all the requested data
+                % points.
+                % If this was an early breakout, don't include
+                % the <Return> key info in the return arrays.
+                % We will no longer count it if it's the last input.
+                break;
+            end
+            
+            axes_handle = gca;            
+            if ~isa(axes_handle,'matlab.graphics.axis.Axes')
+                % If gca is not an axes, warn but keep listening for clicks. 
+                % (There may still be other subplots with valid axes)
+                warning(message('MATLAB:Chart:UnsupportedConvenienceFunction', 'ginput', axes_handle.Type));
+                continue            
+            end
+            
+            drawnow;
+            pt = get(axes_handle, 'CurrentPoint');            
+            how_many = how_many - 1;
+            
+
+            
+            out1 = [out1;pt(1,1)]; %#ok<AGROW>
+            y = [y;pt(1,2)]; %#ok<AGROW>
+            b = [b;button]; %#ok<AGROW>
+        end
+    end
+    
+    % Cleanup and Restore 
+    cleanup(c);
+    
+    if nargout > 1
+        out2 = y;
+        if nargout > 2
+            out3 = b;
+        end
+    else
+        out1 = [out1 y];
+    end
+    
+end
+
+function valid = isPositiveScalarIntegerNumber(how_many) 
+valid = ~ischar(how_many) && ...            % is numeric
+        isscalar(how_many) && ...           % is scalar
+        (fix(how_many) == how_many) && ...  % is integer in value
+        how_many >= 0;                      % is positive
+end
+
+function key = wfbp
+%WFBP   Replacement for WAITFORBUTTONPRESS that has no side effects.
+
+fig = gcf;
+current_char = []; %#ok<NASGU>
+
+% Now wait for that buttonpress, and check for error conditions
+waserr = 0;
+try
+    h=findall(fig,'Type','uimenu','Accelerator','C');   % Disabling ^C for edit menu so the only ^C is for
+    set(h,'Accelerator','');                            % interrupting the function.
+    keydown = waitforbuttonpress;
+    current_char = double(get(fig,'CurrentCharacter')); % Capturing the character.
+    if~isempty(current_char) && (keydown == 1)          % If the character was generated by the
+        if(current_char == 3)                           % current keypress AND is ^C, set 'waserr'to 1
+            waserr = 1;                                 % so that it errors out.
+        end
+    end
+    
+    set(h,'Accelerator','C');                           % Set back the accelerator for edit menu.
+catch %#ok<CTCH>
+    waserr = 1;
+end
+drawnow;
+if(waserr == 1)
+    set(h,'Accelerator','C');                          % Set back the accelerator if it errored out.
+    error(message('MATLAB:ginput:Interrupted'));
+end
+
+if nargout>0, key = keydown; end
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+end
+
+function initialState = setupFcn(fig)
+
+% Store Figure Handle. 
+initialState.figureHandle = fig; 
+
+% Suspend figure functions
+initialState.uisuspendState = uisuspend(fig);
+
+% Disable Plottools Buttons
+initialState.toolbar = findobj(allchild(fig),'flat','Type','uitoolbar');
+if ~isempty(initialState.toolbar)
+    initialState.ptButtons = [uigettool(initialState.toolbar,'Plottools.PlottoolsOff'), ...
+        uigettool(initialState.toolbar,'Plottools.PlottoolsOn')];
+    initialState.ptState = get (initialState.ptButtons,'Enable');
+    set (initialState.ptButtons,'Enable','off');
+end
+
+%Setup empty pointer
+cdata = NaN(16,16);
+hotspot = [8,8];
+set(gcf,'Pointer','custom','PointerShapeCData',cdata,'PointerShapeHotSpot',hotspot)
+
+% Create uicontrols to simulate fullcrosshair pointer.
+initialState.CrossHair = createCrossHair(fig);
+
+% Adding this to enable automatic updating of currentpoint on the figure 
+% This function is also used to update the display of the fullcrosshair
+% pointer and make them track the currentpoint.
+set(fig,'WindowButtonMotionFcn',@(o,e) dummy()); % Add dummy so that the CurrentPoint is constantly updated
+initialState.MouseListener = addlistener(fig,'WindowMouseMotion', @(o,e) updateCrossHair(o,initialState.CrossHair));
+
+% Get the initial Figure Units
+initialState.fig_units = get(fig,'Units');
+end
+
+function restoreFcn(initialState)
+if ishghandle(initialState.figureHandle)
+    delete(initialState.CrossHair);
+    
+    % Figure Units
+    set(initialState.figureHandle,'Units',initialState.fig_units);
+    
+    set(initialState.figureHandle,'WindowButtonMotionFcn','');
+    delete(initialState.MouseListener);
+    
+    % Plottools Icons
+    if ~isempty(initialState.toolbar) && ~isempty(initialState.ptButtons)
+        set (initialState.ptButtons(1),'Enable',initialState.ptState{1});
+        set (initialState.ptButtons(2),'Enable',initialState.ptState{2});
+    end
+    
+    % UISUSPEND
+    uirestore(initialState.uisuspendState);    
+end
+end
+
+function updateCrossHair(fig, crossHair)
+% update cross hair for figure.
+gap = 3; % 3 pixel view port between the crosshairs
+cp = hgconvertunits(fig, [fig.CurrentPoint 0 0], fig.Units, 'pixels', fig);
+cp = cp(1:2);
+figPos = hgconvertunits(fig, fig.Position, fig.Units, 'pixels', fig.Parent);
+figWidth = figPos(3);
+figHeight = figPos(4);
+
+% Early return if point is outside the figure
+if cp(1) < gap || cp(2) < gap || cp(1)>figWidth-gap || cp(2)>figHeight-gap
+    return
+end
+
+set(crossHair, 'Visible', 'on');
+thickness = 1; % 1 Pixel thin lines. 
+set(crossHair(1), 'Position', [0 cp(2) cp(1)-gap thickness]);
+set(crossHair(2), 'Position', [cp(1)+gap cp(2) figWidth-cp(1)-gap thickness]);
+set(crossHair(3), 'Position', [cp(1) 0 thickness cp(2)-gap]);
+set(crossHair(4), 'Position', [cp(1) cp(2)+gap thickness figHeight-cp(2)-gap]);
+end
+
+function crossHair = createCrossHair(fig)
+% Create thin uicontrols with black backgrounds to simulate fullcrosshair pointer.
+% 1: horizontal left, 2: horizontal right, 3: vertical bottom, 4: vertical top
+for k = 1:4
+    crossHair(k) = uicontrol(fig, 'Style', 'text', 'Visible', 'off', 'Units', 'pixels', 'BackgroundColor', [1 1 1], 'HandleVisibility', 'off', 'HitTest', 'off'); %#ok<AGROW>
+end
+end
+
+function cleanup(c)
+if isvalid(c)
+    delete(c);
+end
+end
+
+function dummy(~,~) 
+end
diff --git a/matlab_script/QuantLib/plot_areaerrorbar.m b/matlab_script/QuantLib/plot_areaerrorbar.m
new file mode 100755
index 0000000000000000000000000000000000000000..13ae7f52e0216bccb00fd2c6c3bd7cb2787dddbe
--- /dev/null
+++ b/matlab_script/QuantLib/plot_areaerrorbar.m
@@ -0,0 +1,71 @@
+% ----------------------------------------------------------------------- %
+% Function plot_areaerrorbar plots the mean and standard deviation of a   %
+% set of data filling the space between the positive and negative mean    %
+% error using a semi-transparent background, completely customizable.     %
+%                                                                         %
+%   Input parameters:                                                     %
+%       - data:     Data matrix, with rows corresponding to observations  %
+%                   and columns to samples.                               %
+%       - options:  (Optional) Struct that contains the customized params.%
+%           * options.handle:       Figure handle to plot the result.     %
+%           * options.color_area:   RGB color of the filled area.         %
+%           * options.color_line:   RGB color of the mean line.           %
+%           * options.alpha:        Alpha value for transparency.         %
+%           * options.line_width:   Mean line width.                      %
+%           * options.x_axis:       X time vector.                        %
+%           * options.error:        Type of error to plot (+/-).          %
+%                   if 'std',       one standard deviation;               %
+%                   if 'sem',       standard error mean;                  %
+%                   if 'var',       one variance;                         %
+%                   if 'c95',       95% confidence interval.              %
+% ----------------------------------------------------------------------- %
+%   Example of use:                                                       %
+%       data = repmat(sin(1:0.01:2*pi),100,1);                            %
+%       data = data + randn(size(data));                                  %
+%       plot_areaerrorbar(data);                                          %
+% ----------------------------------------------------------------------- %
+%   Author:  Victor Martinez-Cagigal                                      %
+%   Date:    30/04/2018                                                   %
+%   E-mail:  vicmarcag (at) gmail (dot) com                               %
+% ----------------------------------------------------------------------- %
+function plot_areaerrorbar(data, options)
+
+    % Default options
+    if(nargin<2)
+        options.handle     = figure(1);
+        options.color_area = [128 193 219]./255;    % Blue theme
+        options.color_line = [ 52 148 186]./255;
+        %options.color_area = [243 169 114]./255;    % Orange theme
+        %options.color_line = [236 112  22]./255;
+        options.alpha      = 0.5;
+        options.line_width = 2;
+        options.error      = 'std';
+    end
+    if(isfield(options,'x_axis')==0), options.x_axis = 1:size(data,2); end
+    options.x_axis = options.x_axis(:);
+    
+    % Computing the mean and standard deviation of the data matrix
+    data_mean = nanmean(data,1);
+    data_std  = nanstd(data,0,1);
+    
+    % Type of error plot
+    switch(options.error)
+        case 'std', error = data_std;
+        case 'sem', error = (data_std./sqrt(size(data,1)));
+        case 'var', error = (data_std.^2);
+        case 'c95', error = (data_std./sqrt(size(data,1))).*1.96;
+    end
+    
+    % Plotting the result
+    figure(options.handle);
+    x_vector = [options.x_axis', fliplr(options.x_axis')];
+    patch = fill(x_vector, [data_mean+error,fliplr(data_mean-error)], options.color_area);
+    set(patch, 'edgecolor', 'none');
+    set(patch, 'FaceAlpha', options.alpha);
+    set(patch, 'HandleVisibility', 'off');
+    hold on;
+    plot(options.x_axis, data_mean, 'color', options.color_line, ...
+        'LineWidth', options.line_width);
+    hold off;
+    
+end
\ No newline at end of file
diff --git a/matlab_script/main_script.m b/matlab_script/main_script.m
new file mode 100755
index 0000000000000000000000000000000000000000..27ba6f5e9d903d6beee6a43526b8241ad0bcdb73
--- /dev/null
+++ b/matlab_script/main_script.m
@@ -0,0 +1,29 @@
+
+%% Sanity clear (avoid workspace error)
+clear all;
+close all;
+clc;
+
+%% Add folder to path
+addpath('QuantLib')
+
+%% Input folder
+input_folder = '../analysis_2021/sagitarial_d12.5';
+
+%% Phenotype list
+% keywords in folder identifying the experiment phenotype
+phenotype = { ...  % folder keyword to identify various phenotype
+    'wt' ; ...
+    'mu' ; ...
+    };
+
+%% Quantities to extract
+% comment or uncomment line to add/remove from extraction
+quantities = { ... 
+    'S'    ; ...                % anisotropy amplitude
+    'angS' ; ...                % anisotropy angle [0:pi]
+    'Intensity'    ; ...        % average intensity 
+    };
+
+%% Run analysis of pipeline quantification
+Analyse(input_folder, quantities, phenotype);
diff --git a/python_script/analysis_myosine.ipynb b/python_script/analysis_myosine.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..aa12e052a2c323419173ac8e0032514068b75c3c
--- /dev/null
+++ b/python_script/analysis_myosine.ipynb
@@ -0,0 +1,456 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Myosine anisotropy analysis"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# HIDE CODE\n",
+    "\n",
+    "import pandas as pd\n",
+    "import os\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import functions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Load compute values from Matlab script"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Phenotype</th>\n",
+       "      <th>Animal</th>\n",
+       "      <th>Area</th>\n",
+       "      <th>Distance</th>\n",
+       "      <th>Intensity</th>\n",
+       "      <th>Angle</th>\n",
+       "      <th>SymAngle</th>\n",
+       "      <th>Shear</th>\n",
+       "      <th>Weight</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>wt</td>\n",
+       "      <td>wt1_sg</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0.453516</td>\n",
+       "      <td>2.844076</td>\n",
+       "      <td>0.297517</td>\n",
+       "      <td>0.184577</td>\n",
+       "      <td>1.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>wt</td>\n",
+       "      <td>wt1_sg</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.380843</td>\n",
+       "      <td>0.046996</td>\n",
+       "      <td>0.046996</td>\n",
+       "      <td>0.249474</td>\n",
+       "      <td>1.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>wt</td>\n",
+       "      <td>wt1_sg</td>\n",
+       "      <td>1</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0.280663</td>\n",
+       "      <td>3.096377</td>\n",
+       "      <td>0.045215</td>\n",
+       "      <td>0.465363</td>\n",
+       "      <td>1.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>wt</td>\n",
+       "      <td>wt1_sg</td>\n",
+       "      <td>1</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.240228</td>\n",
+       "      <td>2.917614</td>\n",
+       "      <td>0.223979</td>\n",
+       "      <td>0.343645</td>\n",
+       "      <td>1.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>wt</td>\n",
+       "      <td>wt1_sg</td>\n",
+       "      <td>1</td>\n",
+       "      <td>4</td>\n",
+       "      <td>0.209207</td>\n",
+       "      <td>2.940003</td>\n",
+       "      <td>0.201590</td>\n",
+       "      <td>0.382913</td>\n",
+       "      <td>1.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "  Phenotype  Animal  Area  Distance  ...     Angle  SymAngle     Shear  Weight\n",
+       "0        wt  wt1_sg     1         0  ...  2.844076  0.297517  0.184577     1.0\n",
+       "1        wt  wt1_sg     1         1  ...  0.046996  0.046996  0.249474     1.0\n",
+       "2        wt  wt1_sg     1         2  ...  3.096377  0.045215  0.465363     1.0\n",
+       "3        wt  wt1_sg     1         3  ...  2.917614  0.223979  0.343645     1.0\n",
+       "4        wt  wt1_sg     1         4  ...  2.940003  0.201590  0.382913     1.0\n",
+       "\n",
+       "[5 rows x 9 columns]"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# HIDE CODE\n",
+    "boxSize = 128       # window pixel size\n",
+    "overlap = 0.5       # window overlap\n",
+    "pixelSize = 0.313   # pixel size\n",
+    "\n",
+    "# Load analysis csv\n",
+    "path = r'../data'\n",
+    "df = pd.read_csv(os.path.join(path, 'quantification.csv'))\n",
+    "df[\"Distance\"] = df[\"Distance\"] - 1\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Converte angle to degree and average values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Phenotype</th>\n",
+       "      <th>Animal</th>\n",
+       "      <th>Distance</th>\n",
+       "      <th>Area</th>\n",
+       "      <th>Intensity</th>\n",
+       "      <th>Angle</th>\n",
+       "      <th>SymAngle</th>\n",
+       "      <th>Shear</th>\n",
+       "      <th>Weight</th>\n",
+       "      <th>SymAngleDeg</th>\n",
+       "      <th>AngleDeg</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>mu</td>\n",
+       "      <td>mut1_sg</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.424760</td>\n",
+       "      <td>1.832534</td>\n",
+       "      <td>0.368228</td>\n",
+       "      <td>0.135266</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>21.097938</td>\n",
+       "      <td>104.996444</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>mu</td>\n",
+       "      <td>mut1_sg</td>\n",
+       "      <td>20.0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.403870</td>\n",
+       "      <td>1.974050</td>\n",
+       "      <td>0.780004</td>\n",
+       "      <td>0.131931</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>44.690926</td>\n",
+       "      <td>113.104754</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>mu</td>\n",
+       "      <td>mut1_sg</td>\n",
+       "      <td>40.0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.354734</td>\n",
+       "      <td>1.776930</td>\n",
+       "      <td>1.197720</td>\n",
+       "      <td>0.142857</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>68.624292</td>\n",
+       "      <td>101.810566</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>mu</td>\n",
+       "      <td>mut1_sg</td>\n",
+       "      <td>60.0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.381712</td>\n",
+       "      <td>1.364795</td>\n",
+       "      <td>1.220794</td>\n",
+       "      <td>0.144526</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>69.946315</td>\n",
+       "      <td>78.197022</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>mu</td>\n",
+       "      <td>mut1_sg</td>\n",
+       "      <td>80.0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.402125</td>\n",
+       "      <td>1.905515</td>\n",
+       "      <td>0.872898</td>\n",
+       "      <td>0.134224</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>50.013358</td>\n",
+       "      <td>109.177945</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "  Phenotype   Animal  Distance  Area  ...     Shear  Weight  SymAngleDeg    AngleDeg\n",
+       "0        mu  mut1_sg       0.0     3  ...  0.135266     1.0    21.097938  104.996444\n",
+       "1        mu  mut1_sg      20.0     3  ...  0.131931     1.0    44.690926  113.104754\n",
+       "2        mu  mut1_sg      40.0     3  ...  0.142857     1.0    68.624292  101.810566\n",
+       "3        mu  mut1_sg      60.0     3  ...  0.144526     1.0    69.946315   78.197022\n",
+       "4        mu  mut1_sg      80.0     3  ...  0.134224     1.0    50.013358  109.177945\n",
+       "\n",
+       "[5 rows x 11 columns]"
+      ]
+     },
+     "execution_count": 35,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# HIDE CODE\n",
+    "data = functions.compute_myosine_orientation(df, boxSize, pixelSize, overlap)\n",
+    "dmin = data[\"Distance\"].min()\n",
+    "dmax = data[\"Distance\"].max()\n",
+    "data.head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Plot Myosine orientation distribution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<seaborn.axisgrid.FacetGrid at 0x7f27141911c0>"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2238.88x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# HIDE CODE\n",
+    "f = sns.relplot(x='Distance', y='SymAngleDeg', hue='Animal', data=data, kind='line', col='Phenotype', col_order=(\"wt\", \"mu\"), height=10, aspect=1.5)\n",
+    "f.set( ylabel='Orientation  (degree)', xlabel='Distance ($\\mu m$)', ylim=(0,90), yticks=[0,30,60,90], xlim=(dmin,dmax))\n",
+    "plt.savefig(\"./detailled.pdf\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<seaborn.axisgrid.FacetGrid at 0x7f2715402ee0>"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1169x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "# HIDE CODE\n",
+    "f = sns.relplot(x='Distance', y='SymAngleDeg', hue='Phenotype', hue_order=(\"wt\", \"mu\"), data=data, kind='line', ci=\"sd\", height=10, aspect=1.5)\n",
+    "f.set(ylabel='Orientation (degree)', xlabel='Distance ($\\mu m$)', ylim=(0,90), yticks=[0,30,60,90], xlim=(dmin,dmax), title=\"Averaged Myosine orientation along proxima-distal axis\")\n",
+    "\n",
+    "plt.savefig(\"./averaged.pdf\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[Text(0.5, 1.05, 'Myosine orientation histogram (0-90 degree).')]"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 720x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# HIDE CODE\n",
+    "wt_ind = data['Phenotype'] == 'wt'\n",
+    "mu_ind = data['Phenotype'] == 'mu'\n",
+    "\n",
+    "fig, ax = plt.subplots(1, subplot_kw=dict(projection='polar'), figsize=(10,10))\n",
+    "functions.rose_plot(ax, data.loc[wt_ind, 'SymAngle'].values, bins=16, fill=True, alpha=0.5, density=True, color='C0')\n",
+    "functions.rose_plot(ax, data.loc[mu_ind, 'SymAngle'].values, bins=16, fill=True, alpha=0.5, density=True, color='C1')\n",
+    "ax.legend(('wt', 'mu'))\n",
+    "ax.set(title=\"Myosine orientation histogram (0-90 degree).\")\n",
+    "\n",
+    "plt.savefig(\"./histo_16.pdf\")\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "interpreter": {
+   "hash": "17f81ec3e8b88fb2959c9efb8cbf099d2f0d5b348c07e1cce5d582fdf4c8d749"
+  },
+  "kernelspec": {
+   "display_name": "Python 3.8.0 64-bit ('cparada': conda)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.3"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python_script/analysis_sox9.ipynb b/python_script/analysis_sox9.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..e686b36f7da87968783067d4e750fc6a40b055cd
--- /dev/null
+++ b/python_script/analysis_sox9.ipynb
@@ -0,0 +1,251 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Sox9 impact of cell anisotropy analysis"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# HIDE CODE\n",
+    "\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import os\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "import functions\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Unnamed: 0</th>\n",
+       "      <th>Phenotype</th>\n",
+       "      <th>Animal</th>\n",
+       "      <th>Area</th>\n",
+       "      <th>Distance</th>\n",
+       "      <th>Intensity</th>\n",
+       "      <th>Angle</th>\n",
+       "      <th>SymAngle</th>\n",
+       "      <th>Shear</th>\n",
+       "      <th>Weight</th>\n",
+       "      <th>Distance Align</th>\n",
+       "      <th>SymAngleDeg</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0</td>\n",
+       "      <td>wt</td>\n",
+       "      <td>wt0_sg</td>\n",
+       "      <td>1</td>\n",
+       "      <td>20.032</td>\n",
+       "      <td>0.021796</td>\n",
+       "      <td>2.868368</td>\n",
+       "      <td>0.273225</td>\n",
+       "      <td>0.364717</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>15.654647</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1</td>\n",
+       "      <td>wt</td>\n",
+       "      <td>wt0_sg</td>\n",
+       "      <td>1</td>\n",
+       "      <td>40.064</td>\n",
+       "      <td>0.029412</td>\n",
+       "      <td>2.031840</td>\n",
+       "      <td>1.109753</td>\n",
+       "      <td>0.100614</td>\n",
+       "      <td>0.881893</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>63.584155</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2</td>\n",
+       "      <td>wt</td>\n",
+       "      <td>wt0_sg</td>\n",
+       "      <td>1</td>\n",
+       "      <td>60.096</td>\n",
+       "      <td>0.043856</td>\n",
+       "      <td>1.558087</td>\n",
+       "      <td>1.558087</td>\n",
+       "      <td>0.061084</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>89.271821</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>3</td>\n",
+       "      <td>wt</td>\n",
+       "      <td>wt0_sg</td>\n",
+       "      <td>1</td>\n",
+       "      <td>20.032</td>\n",
+       "      <td>0.021562</td>\n",
+       "      <td>2.979147</td>\n",
+       "      <td>0.162445</td>\n",
+       "      <td>0.337215</td>\n",
+       "      <td>0.020828</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>9.307441</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>4</td>\n",
+       "      <td>wt</td>\n",
+       "      <td>wt0_sg</td>\n",
+       "      <td>1</td>\n",
+       "      <td>40.064</td>\n",
+       "      <td>0.028574</td>\n",
+       "      <td>2.231055</td>\n",
+       "      <td>0.910538</td>\n",
+       "      <td>0.072068</td>\n",
+       "      <td>0.997396</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>52.169964</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   Unnamed: 0 Phenotype  Animal  ...    Weight  Distance Align  SymAngleDeg\n",
+       "0           0        wt  wt0_sg  ...  0.000000             NaN    15.654647\n",
+       "1           1        wt  wt0_sg  ...  0.881893             NaN    63.584155\n",
+       "2           2        wt  wt0_sg  ...  1.000000             NaN    89.271821\n",
+       "3           3        wt  wt0_sg  ...  0.020828             NaN     9.307441\n",
+       "4           4        wt  wt0_sg  ...  0.997396             NaN    52.169964\n",
+       "\n",
+       "[5 rows x 12 columns]"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# HIDE CODE\n",
+    "tau = 0.25          # weight threshold\n",
+    "boxSize = 128       # window pixel size\n",
+    "overlap = 0.5       # window overlap\n",
+    "pixelSize = 0.313   # pixel size\n",
+    "\n",
+    "## Load analysis csv\n",
+    "path = r'../data/'\n",
+    "df = pd.read_csv(os.path.join(path, 'quantification.csv'))\n",
+    "df['Distance'] = df['Distance'] * (boxSize * overlap) * pixelSize\n",
+    "df['SymAngleDeg'] = df['SymAngle'].transform(np.rad2deg)\n",
+    "\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x7f84e5c7f4c0>"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1440x720 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# HIDE CODE\n",
+    "\n",
+    "wt_ind = df['Phenotype'] == 'wt'\n",
+    "mu_ind = df['Phenotype'] == 'mu'\n",
+    "r2_ind = df['Area'] == 2\n",
+    "r1_ind = df['Area'] == 1\n",
+    "ar_ind = df['Weight'] >= tau\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 2, subplot_kw=dict(projection='polar'), figsize=(20,10))\n",
+    "functions.rose_plot(ax[0], df.loc[wt_ind & r1_ind & ar_ind, 'SymAngle'].values, bins=18, fill=True, alpha=0.5, density=True, color='C0')\n",
+    "functions.rose_plot(ax[0], df.loc[wt_ind & r2_ind & ar_ind, 'SymAngle'].values, bins=18, fill=True, alpha=0.5, density=True, color='C1')\n",
+    "functions.rose_plot(ax[1], df.loc[mu_ind & r1_ind & ar_ind, 'SymAngle'].values, bins=18, fill=True, alpha=0.5, density=True, color='C0')\n",
+    "functions.rose_plot(ax[1], df.loc[mu_ind & r2_ind & ar_ind, 'SymAngle'].values, bins=18, fill=True, alpha=0.5, density=True, color='C1')\n",
+    "ax[0].set(title=\"Control cell orientation histogram\")\n",
+    "ax[1].set(title=\"$Wnt5a^{-/-}$ cell orientation histogram\")\n",
+    "ax[1].legend(('Sox9-', 'Sox9+'))"
+   ]
+  }
+ ],
+ "metadata": {
+  "interpreter": {
+   "hash": "17f81ec3e8b88fb2959c9efb8cbf099d2f0d5b348c07e1cce5d582fdf4c8d749"
+  },
+  "kernelspec": {
+   "display_name": "Python 3.8.0 64-bit ('cparada': conda)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.3"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/python_script/functions.py b/python_script/functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2abef0ba378b30ac492f60ecd80b758e9285e32
--- /dev/null
+++ b/python_script/functions.py
@@ -0,0 +1,65 @@
+import numpy as np
+import pandas as pd
+
+def compute_myosine_orientation(df, boxSize, pixelsize, overlap):
+    df = df[df["Area"] == 3]
+    data = df.groupby(["Phenotype","Animal","Distance"]).mean()
+    data.reset_index(inplace=True)
+    data['Distance'] = np.round(data['Distance'] * (boxSize * overlap) * pixelsize)
+    data['SymAngleDeg'] = data['SymAngle'].transform(np.rad2deg)   
+    data['AngleDeg'] = data['Angle'].transform(np.rad2deg)  
+
+    data.drop(data[data['Distance'] > 300].index, inplace = True)
+    return data
+
+def rose_plot(ax, angles, bins=18, density=None, offset=0, lab_unit="degrees",
+              start_zero=False, color=None, lw=1, alpha=1, fill=False, **param_dict):
+    """
+    Plot polar histogram of angles on ax. ax must have been created using
+    subplot_kw=dict(projection='polar'). Angles are expected in radians.
+    """
+    # Wrap angles to [-pi, pi)
+    angles = (angles + np.pi) % (2 * np.pi) - np.pi
+
+    # Set bins symetrically around zero
+    if start_zero:
+        # To have a bin edge at zero use an even number of bins
+        if bins % 2:
+            bins += 1
+        bins = np.linspace(-np.pi, np.pi, num=bins + 1)
+
+    # Bin data and record counts
+    count, bin = np.histogram(angles, bins=bins)
+
+    # Compute width of each bin
+    widths = np.diff(bin)
+
+    # By default plot density (frequency potentially misleading)
+    if density is None or density is True:
+        # Area to assign each bin
+        area = count / angles.size
+        # Calculate corresponding bin radius
+        radius = (area / np.pi) ** .5
+    else:
+        radius = count
+
+    # Plot data on ax
+    ax.bar(bin[:-1], radius, zorder=1, align='edge', width=widths,
+           edgecolor=color, fill=fill, linewidth=lw, alpha=alpha)
+
+    # Set the direction of the zero angle
+    # ax.set_theta_offset(offset)
+    ax.set_theta_zero_location('E', offset=offset)
+
+    # Remove ylabels, they are mostly obstructive and not informativemy_yticks
+    ax.set(ylim=(0, 0.3))
+    ax.set(xlim=(0,np.pi))
+    # ax.set_yticks([])
+    ax.set_yticks([0,0.1,0.2,0.3])
+    ax.set_xticks([0, np.pi/6, np.pi/3, np.pi/2, np.pi-(np.pi/3), np.pi-(np.pi/6), np.pi])
+    ax.tick_params(axis='y', which='major')#, labelsize=20)
+
+    if lab_unit == "radians":
+        label = ['$0$', r'$\pi/4$', r'$\pi/2$', r'$3\pi/4$',
+                 r'$\pi$', r'$5\pi/4$', r'$3\pi/2$', r'$7\pi/4$']
+        ax.set_xticklabels(label)
\ No newline at end of file
diff --git a/python_script/requirements.txt b/python_script/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..08aa8047ad95019713a04ba6f8755aab48005c90
--- /dev/null
+++ b/python_script/requirements.txt
@@ -0,0 +1,158 @@
+alabaster==0.7.12
+anyio==3.3.1
+appdirs==1.4.4
+argon2-cffi==21.1.0
+attrs==20.3.0
+Babel==2.9.1
+backcall==0.2.0
+beautifulsoup4==4.10.0
+bleach==4.1.0
+cachey==0.2.1
+certifi==2021.5.30
+cffi==1.14.6
+charset-normalizer==2.0.6
+click==7.1.2
+cloudpickle==2.0.0
+colorama==0.4.4
+cycler==0.10.0
+dask==2021.9.1
+debugpy==1.4.3
+decorator==5.1.0
+defusedxml==0.7.1
+docstring-parser==0.10
+docutils==0.16
+entrypoints==0.3
+freetype-py==2.2.0
+fsspec==2021.9.0
+gitdb==4.0.7
+GitPython==3.1.24
+greenlet==1.1.1
+h5py==3.4.0
+HeapDict==1.0.1
+hsluv==5.0.2
+idna==3.2
+imageio==2.9.0
+imagesize==1.2.0
+importlib-metadata==4.8.1
+ipykernel==6.4.1
+ipython==7.27.0
+ipython-genutils==0.2.0
+ipywidgets==7.6.5
+jedi==0.18.0
+Jinja2==3.0.1
+jsonschema==3.2.0
+jupyter==1.0.0
+jupyter-book==0.11.3
+jupyter-cache==0.4.3
+jupyter-client==7.0.3
+jupyter-console==6.4.0
+jupyter-core==4.8.1
+jupyter-server==1.11.0
+jupyter-server-mathjax==0.2.3
+jupyter-sphinx==0.3.2
+jupyterlab-widgets==1.0.2
+jupytext==1.10.3
+kiwisolver==1.3.2
+latexcodec==2.0.1
+linkify-it-py==1.0.1
+locket==0.2.1
+magicgui==0.2.11
+markdown-it-py==0.6.2
+MarkupSafe==2.0.1
+matplotlib==3.4.3
+matplotlib-inline==0.1.3
+mdit-py-plugins==0.2.6
+mistune==0.8.4
+myst-nb==0.12.3
+myst-parser==0.13.7
+napari==0.4.11
+napari-console==0.0.4
+napari-plugin-engine==0.2.0
+napari-svg==0.1.5
+nbclient==0.5.4
+nbconvert==5.6.1
+nbdime==3.1.0
+nbformat==5.1.3
+nest-asyncio==1.5.1
+networkx==2.6.3
+notebook==6.4.4
+numpy==1.21.2
+numpydoc==1.1.0
+packaging==21.0
+pandas==1.3.3
+pandocfilters==1.5.0
+parso==0.8.2
+partd==1.2.0
+pexpect==4.8.0
+pickleshare==0.7.5
+Pillow==8.3.2
+Pint==0.17
+prometheus-client==0.11.0
+prompt-toolkit==3.0.20
+psutil==5.8.0
+ptyprocess==0.7.0
+pybtex==0.24.0
+pybtex-docutils==1.0.1
+pycparser==2.20
+pydantic==1.8.2
+pydata-sphinx-theme==0.6.3
+Pygments==2.10.0
+PyOpenGL==3.1.5
+pyparsing==2.4.7
+pyrsistent==0.18.0
+python-dateutil==2.8.2
+pytz==2021.1
+PyWavelets==1.1.1
+PyYAML==5.4.1
+pyzmq==22.3.0
+qtconsole==5.1.1
+QtPy==1.11.1
+requests==2.26.0
+requests-unixsocket==0.2.0
+runipy==0.1.5
+scikit-image==0.18.3
+scipy==1.7.1
+seaborn==0.11.2
+Send2Trash==1.8.0
+six==1.16.0
+smmap==4.0.0
+sniffio==1.2.0
+snowballstemmer==2.1.0
+soupsieve==2.2.1
+Sphinx==3.5.4
+sphinx-book-theme==0.1.4
+sphinx-comments==0.0.3
+sphinx-copybutton==0.4.0
+sphinx-external-toc==0.2.3
+sphinx-jupyterbook-latex==0.4.2
+sphinx-multitoc-numbering==0.1.3
+sphinx-panels==0.5.2
+sphinx-thebe==0.0.10
+sphinx-togglebutton==0.2.3
+sphinxcontrib-applehelp==1.0.2
+sphinxcontrib-bibtex==2.2.1
+sphinxcontrib-devhelp==1.0.2
+sphinxcontrib-htmlhelp==2.0.0
+sphinxcontrib-jsmath==1.0.1
+sphinxcontrib-qthelp==1.0.3
+sphinxcontrib-serializinghtml==1.1.5
+SQLAlchemy==1.4.23
+superqt==0.2.4
+terminado==0.12.1
+testpath==0.5.0
+tifffile==2021.8.30
+toml==0.10.2
+toolz==0.11.1
+tornado==6.1
+tqdm==4.62.3
+traitlets==5.1.0
+typing-extensions==3.10.0.2
+uc-micro-py==1.0.1
+urllib3==1.26.6
+vispy==0.8.1
+wcwidth==0.2.5
+webencodings==0.5.1
+websocket-client==1.2.1
+widgetsnbextension==3.5.1
+wrapt==1.12.1
+zipp==3.5.0