ararpy 0.1.199__py3-none-any.whl → 0.2.1__py3-none-any.whl

ararpy/smp/export.py

@@ -19,18 +19,26 @@ import pickle
 import traceback
 import pdf_maker as pm
 import numpy as np
+from math import log
 from decimal import Decimal
 
 from ..calc import arr, isochron, spectra, err
-from ..calc.basic import get_random_digits
+from ..calc.basic import random_choice, merge_dicts
 from ..calc.plot import get_axis_scale
 from . import basic, sample, consts
 
 Sample = sample.Sample
 Plot = sample.Plot
 
-title_size = 11
-label_size = 11
+title_size = 8
+label_size = 8
+
+colors_map = {
+    'red': "#EF661B",
+    'blue': "#189CCA",
+    'red80': "#FFB593",
+    'blue80': "#6BD2FF",
+}
 
 try:
     from webarar.settings import SETTINGS_ROOT
@@ -53,8 +61,12 @@ def get_cv_from_dict(data: dict, **kwargs):
     cv = pm.Canvas(width=kwargs.get("width", 17), height=kwargs.get("height", 12),
                    unit="cm", show_frame=False, clip_outside_plot_areas=False)
     # change frame outline style
-    if kwargs.get("show_frame", True):
+    if kwargs.get("show_frame", False):
         cv.show_frame(color="grey", line_width=0.5)
+    # stick length
+    stick_length = kwargs.get("stick_length", 3)
+    ylabel_offset = kwargs.get("ylabel_offset", 2)
+    xlabel_offset = kwargs.get("xlabel_offset", 8)
     axis_num = min([len(data['xAxis']), len(data['yAxis'])])
     # draw axis
     plots = []
@@ -63,28 +75,28 @@ def get_cv_from_dict(data: dict, **kwargs):
         scale = (float(scale[0]), float(scale[1]), float(scale[2]), float(scale[3]))
         # create plot area based on axis scale
         plot_area = (kwargs.get("pt_left", 0.15), kwargs.get("pt_bottom", 0.15), kwargs.get("pt_width", 0.8), kwargs.get("pt_height", 0.8))
-        pt = cv.add_plot_area(name=f"PlotArea{i}", plot_area=plot_area, plot_scale=scale, show_frame=True)
+        pt = cv.add_plot_area(name=f"PlotArea{i}", plot_area=plot_area, plot_scale=scale, **data['xAxis'][i])
         for stick in data['xAxis'][i]['interval']:
             start = pt.scale_to_points(float(stick), scale[2])
             end = pt.scale_to_points(float(stick), scale[2])
-            end = (end[0], end[1] - 5)
-            if pt.line(start=start, end=end, width=1, line_style="solid", y_clip=False, coordinate="pt", z_index=100):
-                pt.text(x=start[0], y=end[1] - 15, text=f"{stick}", clip=False, size=int(data['xAxis'][i]['label_size']),
+            end = (end[0], end[1] - stick_length)
+            if pt.line(start=start, end=end, width=data['xAxis'][i].get('line_width', 1), line_style="solid", y_clip=False, coordinate="pt", z_index=100):
+                pt.text(x=start[0], y=end[1] - xlabel_offset, text=f"{stick}", clip=False, size=int(data['xAxis'][i].get('label_size', 8)),
                         coordinate="pt", h_align="middle", z_index=150)
         for stick in data['yAxis'][i]['interval']:
             start = pt.scale_to_points(scale[0], float(stick))
             end = pt.scale_to_points(scale[0], float(stick))
-            end = (end[0] - 5, end[1])
-            if pt.line(start=start, end=end, width=1, line_style="solid", x_clip=False, coordinate="pt", z_index=100):
-                pt.text(x=end[0] - 5, y=end[1], text=f"{stick}", clip=False, size=int(data['yAxis'][i]['label_size']),
+            end = (end[0] - stick_length, end[1])
+            if pt.line(start=start, end=end, width=data['xAxis'][i].get('line_width', 1), line_style="solid", x_clip=False, coordinate="pt", z_index=100):
+                pt.text(x=end[0] - ylabel_offset, y=end[1], text=f"{stick}", clip=False, size=int(data['yAxis'][i].get('label_size', 8)),
                         coordinate="pt", h_align="right", v_align="center", z_index=150)
         # axis titles
         nloc = pt.scale_to_points(sum(scale[:2]) / 2, scale[2])
-        pt.text(x=nloc[0], y=nloc[1] - kwargs.get("offset_bottom", 30), text=data['xAxis'][i]['title'], clip=False, coordinate="pt",
-                h_align="middle", v_align="center", z_index=150, size=int(data['xAxis'][i]['title_size']))
+        pt.text(x=nloc[0], y=nloc[1] - kwargs.get("offset_bottom", 30), text=data['xAxis'][i].get('title', 'title'), clip=False, coordinate="pt",
+                h_align="middle", v_align="center", z_index=150, size=int(data['xAxis'][i].get('title_size', 8)))
         nloc = pt.scale_to_points(scale[0], sum(scale[2:4]) / 2)
-        pt.text(x=nloc[0] - kwargs.get("offset_left", 50), y=nloc[1], text=data['yAxis'][i]['title'], clip=False, coordinate="pt",
-                h_align="middle", v_align="center", rotate=90, z_index=150, size=int(data['yAxis'][i]['title_size']))
+        pt.text(x=nloc[0] - kwargs.get("offset_left", 50), y=nloc[1], text=data['yAxis'][i].get('title', 'title'), clip=False, coordinate="pt",
+                h_align="middle", v_align="center", rotate=90, z_index=150, size=int(data['yAxis'][i].get('title_size', 8)))
         plots.append(pt)
     # draw series
     for se in data['series']:
@@ -102,20 +114,23 @@ def get_cv_from_dict(data: dict, **kwargs):
         except IndexError:
             continue
         if 'line' in se['type']:
+            se['width'] = se.get('line_width', 1)
+            se['line_style'] = se.get('line_style', 'solid')
+            se['color'] = se.get('color', 'black')
+            se['line_caps'] = se.get('line_caps', 'none')
+            se['z_index'] = int(se.get('z_index', 9))
             for index in range(1, len(data)):
-                pt.line(
-                    start=data[index - 1], end=data[index], width=se.get('line_width', 1),
-                    line_style=se.get('line_style', 'solid'), name=se['name'],
-                    color=se.get('color', 'black'), clip=True, line_caps=se.get('line_caps', 'none'),
-                    z_index=se.get('z_index', 9))
+                pt.line(start=data[index - 1], end=data[index], **se)
         if 'scatter' in se['type'] and se['name'] != 'Text':
+            se['fill_color'] = se.get('fill_color', 'black')
+            se['size'] = se.get('size', 5)
+            se['stroke_color'] = se.get('stroke_color', se.get('color', 'black'))
+            se['z_index'] = int(se.get('z_index', 9))
+            se['marker'] = se.get('marker', 'rec')
             for each in data:
-                pt.scatter(
-                    each[0], each[1], fill_color=se.get('fill_color', 'black'), size=se.get('size', 5),
-                    stroke_color=se.get('stroke_color', se.get('color', 'black')),
-                    z_index=se.get('z_index', 9)
-                )
+                pt.scatter(each[0], each[1], **se)
         if 'scatter' in se['type'] and se['name'] == 'Text' or 'text' in se['type']:
+            se.update({'size': 10})
             for each in data:
                 pt.text(*each[:2], **se)
         if 'rect' in se['type']:
@@ -181,6 +196,12 @@ def export_chart_to_pdf(cvs, file_name: str = "", file_path: str = "", **kwargs)
     -------
 
     """
+    # capital letter for label
+    def get_label(l="", num=0):
+        if num // 26 > 0:
+            return get_label(get_label(l, num // 26 - 1), num % 26)
+        return l + chr(num % 26 + 65)
+
     # write pdf
     show_label = kwargs.get('show_label', False)
     num_cols = kwargs.get('num_columns', 2)
@@ -195,21 +216,12 @@ def export_chart_to_pdf(cvs, file_name: str = "", file_path: str = "", **kwargs)
         file.del_obj(i)
     file.add_page(size=page_size[kwargs.get('page_size', 'a4').lower()], unit='mm')
     for page_index, page in enumerate(cvs):
-
-        # for x in range(0, 600, 10):
-        #     file.line(page_index, start=(x, 0), end=(x, 900), style='dash', color='grey')
-        # for y in range(0, 900, 10):
-        #     file.line(page_index, start=(0, y), end=(800, y), style='dash', color='grey')
-
-        numbers = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N']
-
         for cv_index, cv in enumerate(page):
             left = 10 + cv_index % num_cols * cv.width()
             top = 20 + cv_index // num_cols * cv.height()
             if show_label:
-                # file.text(page=page_index, x=left + 65, y=810 - top, text=numbers[cv_index])
                 cv._plot_areas[1].text(
-                    x=5, y=95, text=numbers[cv_index],
+                    x=5, y=95, text=f"({str(get_label(num=cv_index)).lower()})",
                     id=f'text-label-{page_index}-{cv_index}',
                     name=f'text-label-{page_index}-{cv_index}',
                     color='black', size=title_size, axis_index=1, h_align='middle', v_align='center'
@@ -312,13 +324,13 @@ def getRectFromSpectra(data):
 
     """
     data = np.array(data)
-    return list(map(lambda index: [data[index,0], min(data[index,[1,2]]), np.diff(data[[index,index+1],0])[0], np.diff(data[index,[1,2]])[0]], list(range(len(data) - 1))))
+    return list(filter(lambda rect: rect[2] != 0 and rect[3] != 0, map(lambda index: [data[index,0], min(data[index,[1,2]]), abs(data[index+1,0] - data[index,0]), abs(data[index,1] - data[index,2])], list(range(len(data) - 1)))))
 
 
 def _get_additional_text_series(name):
     return {
-        'type': 'text', 'id': f'text-{name}-{get_random_digits()}',
-        'name': f'text-{name}-{get_random_digits()}', 'color': 'black',
+        'type': 'text', 'id': f'text-{name}-{random_choice()}',
+        'name': f'text-{name}-{random_choice()}', 'color': 'black',
         'text': "", 'size': title_size,
         'data': [[50, 50]], 'axis_index': 1,
         'h_align': "middle", 'v_align': "center",
@@ -327,28 +339,30 @@ def _get_additional_text_series(name):
 
 def _get_plot_data_age_spectra_series(smp: sample, **options):
     color = options.get('color', 'black')
-    sigma = options.get('sigma', 1)
+    sigma = options.get('sigma', smp.Info.preference.confidence_level)
+    unit = options.get('unit', smp.Info.preference.age_unit)
     xAxis = options.get('xAxis', [{}])
     yAxis = options.get('yAxis', [{}])
+    line_width = options.get('line_width', 1)
+    line_caps = options.get('line_caps', 'none')
     series = []
+    # apparent spectra lines
     age = smp.ApparentAgeValues[2:4]
     ar = smp.DegasValues[20]
-    data = spectra.get_data(*age, ar, cumulative=False)
+    x, y1, y2 = spectra.get_data(*age, ar, cumulative=False, sigma=sigma)
+    X = x + list(reversed(x))
+    Y = y1 + list(reversed(y2))
     series.append({
-        'type': 'series.line', 'id': f'line-{smp.name()}-{get_random_digits()}', 'name': f'line-{smp.name()}-{get_random_digits()}',
-        'color': color, 'fill_color': color, 'line_width': 1, 'line_style': 'solid', 'z_index': 9,
-        'data': np.transpose([data[0], data[1]]).tolist(), 'line_caps': 'square',
-        'axis_index': 0,
-    })
-    series.append({
-        'type': 'series.line', 'id': f'line-{smp.name()}-{get_random_digits()}', 'name': f'line-{smp.name()}-{get_random_digits()}',
-        'color': color, 'fill_color': color, 'line_width': 1, 'line_style': 'solid', 'z_index': 9,
-        'data': np.transpose([data[0], data[2]]).tolist(), 'line_caps': 'square',
+        'type': 'series.line', 'id': f'line-{smp.name()}-{random_choice()}', 'name': f'line-{smp.name()}-{random_choice()}',
+        'color': color, 'fill_color': color, 'line_width': line_width, 'line_style': 'solid', 'z_index': 19,
+        'data': np.transpose([X, Y]).tolist(),
+        'line_caps': line_caps,
+        # 'line_caps': 'none',
         'axis_index': 0,
     })
+    # initial values corrected spectra lines and rect
     text1 = smp.AgeSpectraPlot.text1
     text2 = smp.AgeSpectraPlot.text2
-    sigma = 1
     set_data = [spectraData2Sgima(smp.AgeSpectraPlot.set1.data, sigma),
                 spectraData2Sgima(smp.AgeSpectraPlot.set2.data, sigma)]
     for index, text in enumerate([text1, text2]):
@@ -359,55 +373,133 @@ def _get_plot_data_age_spectra_series(smp: sample, **options):
             # spectra_fill_data = list(map(lambda each: [data[0][each - 1], min(data[1][each], data[2][each]), data[0][each + 1] - data[0][each], sigma * abs(data[1][each] - data[2][each])], selection))
             spectra_fill_data = getRectFromSpectra(plateau_data)
             series.append({
-                'type': 'series.rect', 'id': f'rect-{smp.name()}-{get_random_digits()}', 'name': f'rect-{smp.name()}-{get_random_digits()}',
-                'color': ['red', 'blue'][index], 'fill_color': ['red', 'blue'][index], 'line_width': 0, 'line_style': 'solid', 'z_index': 9,
-                'data': spectra_fill_data, 'line_caps': 'square', 'fill': True,
+                'type': 'series.rect', 'id': f'rect-{smp.name()}-{random_choice()}', 'name': f'rect-{smp.name()}-{random_choice()}',
+                'color': [colors_map['red'], colors_map['blue']][index], 'fill_color': [colors_map['red'], colors_map['blue']][index],   'line_style': 'none', 'z_index': 9,
+                'data': spectra_fill_data, 'line_caps': 'none', 'fill': True,
                 'axis_index': 0,
             })
+            x, y1, y2 = np.transpose(plateau_data).tolist()[:3]
+            X = x + list(reversed(x))
+            Y = y1 + list(reversed(y2))
             series.append({
-                'type': 'series.line', 'id': f'line-{smp.name()}-{get_random_digits()}',
-                'name': f'line-{smp.name()}-{get_random_digits()}',
-                'color': ['red', 'blue'][index], 'line_width': 1, 'line_style': 'solid', 'z_index': 9,
-                'data': plateau_data[:,[0,1]].tolist(), 'line_caps': 'square',
+                'type': 'series.line', 'id': f'line-{smp.name()}-{random_choice()}',
+                'name': f'line-{smp.name()}-{random_choice()}',
+                'color': [colors_map['red'], colors_map['blue']][index], 'line_width': line_width, 'line_style': 'solid', 'z_index': 9,
+                'data': np.transpose([X, Y]).tolist(),
+                'line_caps': line_caps,
+                # 'line_caps': 'none',
                 'axis_index': 0,
             })
+            # plateau line
             series.append({
-                'type': 'series.line', 'id': f'line-{smp.name()}-{get_random_digits()}',
-                'name': f'line-{smp.name()}-{get_random_digits()}',
-                'color': ['red', 'blue'][index], 'line_width': 1, 'line_style': 'solid', 'z_index': 9,
-                'data': plateau_data[:,[0,2]].tolist(), 'line_caps': 'square',
+                'type': 'series.line', 'id': f'line-{smp.name()}-{random_choice()}',
+                'name': f'line-{smp.name()}-{random_choice()}',
+                'color': '#A9A9A9', 'line_width': line_width, 'line_style': 'solid', 'z_index': 9,
+                'data': [[0, res['age']], [100, res['age']]],
+                'line_caps': line_caps,
+                # 'line_caps': 'none',
                 'axis_index': 0,
             })
             series.append({
-                'type': 'text', 'id': f'text-{smp.name()}-{get_random_digits()}', 'name': f'text-{smp.name()}-{get_random_digits()}',
-                'color': ['red', 'blue'][index], 'fill_color': ['red', 'blue'][index],
-                'text': f"WMPA = {res['age']:.2f} ± {(sigma * res['s3']):.2f} Ma<r>"
+                'type': 'text', 'id': f'text-{smp.name()}-{random_choice()}', 'name': f'text-{smp.name()}-{random_choice()}',
+                'color': [colors_map['red'], colors_map['blue']][index], 'fill_color': [colors_map['red'], colors_map['blue']][index],
+                'text': f"Corrected = {res['age']:.2f} ± {(sigma * res['s2']):.2f} {unit} ({sigma}s)<r>"
                         f"MSWD = {res['MSWD']:.2f}, n = {res['Num']:.0f}<r>"
                         f"<sup>39</sup>Ar = {res['Ar39']:.2f}%",
                 'size': title_size,
-                'data': [text.pos],
-                'axis_index': 1,
+                # 'data': [text.pos],
+                'data': [[50, 50]],
+                'axis_index': 1, 'z_index': 29,
                 'h_align': "middle",
                 'v_align': "center",
             })
+        spe = smp.Info.results.age_spectra[index]
+        if not np.isnan(res['age']):
+            series.append({
+                'type': 'text', 'id': f'text-{smp.name()}-{random_choice()}',
+                'name': f'text-{smp.name()}-{random_choice()}',
+                'color': color, 'fill_color': color,
+                'text': f"WMPA = {spe['age']:.2f} ± {(sigma * spe['s2']):.2f} {unit} ({sigma}s)",
+                'size': title_size,
+                'data': [[50, 10+10*index]],
+                'axis_index': 1,
+                'h_align': "middle",
+                'v_align': "bottom",
+            })
+
+    # TGA
     tga = smp.Info.results.age_spectra['TGA']
     if not np.isnan(tga['age']):
         series.append({
-            'type': 'text', 'id': f'text-{smp.name()}-{get_random_digits()}', 'name': f'text-{smp.name()}-{get_random_digits()}',
+            'type': 'text', 'id': f'text-{smp.name()}-{random_choice()}', 'name': f'text-{smp.name()}-{random_choice()}',
             'color': color, 'fill_color': color,
-            'text': f"TGA = {tga['age']:.2f} ± {(sigma * tga['s3']):.2f} Ma",
+            'text': f"TGA = {tga['age']:.2f} ± {(sigma * tga['s2']):.2f} {unit} ({sigma}s)",
             'size': title_size,
             'data': [[50, 3]],
             'axis_index': 1,
             'h_align': "middle",
             'v_align': "bottom",
         })
+    # Max
+    age = np.array(smp.ApparentAgeValues[2:8]).transpose()
+    age = np.where(age is None, np.nan, age)
+    valid_mask = np.isfinite(age[:, 0])
+    age = age[valid_mask]
+    age = age[age[:, 5] >= 0.1]
+    try:
+        max_index = np.argmax(age[20:, 0]) + 20
+    except ValueError:
+        max_index = np.argmax(age[10:, 0]) + 10
+    min_index = np.argmin(age[:20, 0])
+    # print(f"{max_index = }")
+    # print(f"{min_index = }")
 
     series.append({
-        'type': 'text', 'id': f'text-{smp.name()}-{get_random_digits()}',
-        'name': f'text-{smp.name()}-{get_random_digits()}', 'color': color,
+        'type': 'text', 'id': f'text-{smp.name()}-{random_choice()}', 'name': f'text-{smp.name()}-{random_choice()}',
+        'color': color, 'fill_color': color,
+        'text': f"Max. = {age[max_index, 0]:.2f} ± {(sigma * age[max_index, 2]):.2f} {unit}",
+        'size': title_size,
+        'data': [[50, 70]],
+        'axis_index': 1,
+        'h_align': "middle",
+        'v_align': "bottom",
+    })
+
+    series.append({
+        'type': 'text', 'id': f'text-{smp.name()}-{random_choice()}', 'name': f'text-{smp.name()}-{random_choice()}',
+        'color': color, 'fill_color': color,
+        'text': f"Min. = {age[min_index, 0]:.2f} ± {(sigma * age[min_index, 2]):.2f} {unit}",
+        'size': title_size,
+        'data': [[50, 75]],
+        'axis_index': 1,
+        'h_align': "middle",
+        'v_align': "bottom",
+    })
+
+    series.append({
+        'type': 'series.line', 'id': f'line-{smp.name()}-{random_choice()}',
+        'name': f'line-{smp.name()}-{random_choice()}',
+        'color': '#A9A9A9', 'line_width': line_width, 'line_style': 'solid', 'z_index': 9,
+        'data': [[0, age[max_index, 0]], [100, age[max_index, 0]]],
+        'line_caps': line_caps,
+        # 'line_caps': 'none',
+        'axis_index': 0,
+    })
+    series.append({
+        'type': 'series.line', 'id': f'line-{smp.name()}-{random_choice()}',
+        'name': f'line-{smp.name()}-{random_choice()}',
+        'color': '#A9A9A9', 'line_width': line_width, 'line_style': 'solid', 'z_index': 9,
+        'data': [[0, age[min_index, 0]], [100, age[min_index, 0]]],
+        'line_caps': line_caps,
+        # 'line_caps': 'none',
+        'axis_index': 0,
+    })
+    # title
+    series.append({
+        'type': 'text', 'id': f'text-{smp.name()}-{random_choice()}',
+        'name': f'text-{smp.name()}-{random_choice()}', 'color': color,
         'text': smp.name(), 'size': title_size,
-        'data': [[50, 95]], 'axis_index': 1,
+        'data': [[50, 95]], 'axis_index': 1, 'z_index': 29,
         'h_align': "middle", 'v_align': "center",
     })
 
@@ -416,50 +508,60 @@ def _get_plot_data_age_spectra_series(smp: sample, **options):
 
 def _get_plot_data_age_spectra_axis(smp: sample, **options):
     color = options.get('color', 'black')
+    line_width = options.get('line_width', 1)
     xAxis, yAxis = [], []
     age = smp.ApparentAgeValues[2:4]
     ar = smp.DegasValues[20]
     data = spectra.get_data(*age, ar, cumulative=False)
 
-    y_low_limit, y_up_limit, stick_num, inc = get_axis_scale(np.array(data[1:3]).flatten())
-    y_extent = [y_low_limit, y_up_limit]
-    y_interval = [y_low_limit + i * inc for i in range(stick_num + 1)]
-    y_interval.extend([y_up_limit * 10] * 3)
-    dp = int(np.log10(abs(y_up_limit - y_low_limit)) - 1)
-    dp = 0 if dp >= 0 else abs(dp)
-    print(f"{dp = }")
-    y_interval = [f"{i:.{dp}f}" for i in y_interval]
-
-    # y_extent = [4, 12]
-    # y_interval = ['0', '10', '20', '30', '40', '50', '60', '70', '80', '90', '100']
-    # y_interval = ['0', '4', '6', '8', '10', '12', '60', '70', '80', '90', '100']
+    # y_low_limit, y_up_limit, stick_num, inc = get_axis_scale(np.array(data[1:3]).flatten())
+    # y_extent = [y_low_limit, y_up_limit]
+    # y_interval = [y_low_limit + i * inc for i in range(stick_num + 1)]
+    # y_interval.extend([y_up_limit * 10] * 3)
+    # dp = int(np.log10(abs(y_up_limit - y_low_limit)) - 1)
+    # dp = 0 if dp >= 0 else abs(dp)
+    # y_interval = [f"{i:.{dp}f}" for i in y_interval]
+    try:
+        y_low_limit = float(smp.AgeSpectraPlot.yaxis.min)
+        y_up_limit = float(smp.AgeSpectraPlot.yaxis.max)
+        y_extent = [y_low_limit, y_up_limit]
+        stick_num = int(smp.AgeSpectraPlot.yaxis.split_number)
+        inc = float(smp.AgeSpectraPlot.yaxis.interval)
+        y_interval = [y_low_limit + i * inc for i in range(stick_num + 1)]
+        dp = int(np.log10(abs(y_up_limit - y_low_limit)) - 1)
+        dp = 0 if dp >= 0 else abs(dp)
+        y_interval = [f"{i:.{dp}f}" for i in y_interval]
+    except (BaseException, Exception):
+        y_extent = [0, 250]
+        y_interval = ['0', '50', '100', '150', '200', '250', '600', '700', '800', '900', '1000']
 
     xAxis.append({
         'extent': [0, 100], 'interval': [0, 20, 40, 60, 80, 100], 'id': 0, 'show_frame': True,
-        'title': 'Cumulative <sup>39</sup>Ar Released (%)', 'name_location': 'middle',
-        'line_width': 1, 'line_style': 'solid', 'z_index': 9, 'label_size': label_size, 'title_size': title_size,
+        'title': 'Cumulative <sup>39</sup>Ar released (%)', 'name_location': 'middle',
+        'line_width': line_width, 'line_style': 'solid', 'z_index': 9, 'label_size': label_size, 'title_size': title_size,
     })
     xAxis.append({
         'extent': [0, 100], 'interval': [], 'id': 1, 'show_frame': False,
         'title': '', 'name_location': 'middle',
-        'line_width': 1, 'line_style': 'solid', 'z_index': 0, 'label_size': label_size, 'title_size': title_size,
+        'line_width': 0, 'line_style': 'none', 'z_index': 0, 'label_size': label_size, 'title_size': title_size,
     })
     yAxis.append({
         'extent': y_extent, 'interval': y_interval,
         'id': 0, 'show_frame': True,
-        'title': 'Apparent Age (Ma)', 'name_location': 'middle',
-        'line_width': 1, 'line_style': 'solid', 'z_index': 9, 'label_size': label_size, 'title_size': title_size,
+        'title': 'Apparent age (Ma)', 'name_location': 'middle',
+        'line_width': line_width, 'line_style': 'solid', 'z_index': 9, 'label_size': label_size, 'title_size': title_size,
     })
     yAxis.append({
         'extent': [0, 100], 'interval': [], 'id': 1, 'show_frame': False,
         'title': '', 'name_location': 'middle',
-        'line_width': 1, 'line_style': 'solid', 'z_index': 0, 'label_size': label_size, 'title_size': title_size,
+        'line_width': 0, 'line_style': 'none', 'z_index': 0, 'label_size': label_size, 'title_size': title_size,
     })
     return xAxis, yAxis
 
 
 def _get_plot_data_inv_isochron_axis(smp: sample, **options):
     color = options.get('color', 'black')
+    line_width = options.get('line_width', 1)
     xAxis, yAxis = [], []
     data = np.array(smp.InvIsochronPlot.data)
     set1 = smp.InvIsochronPlot.set1.data
@@ -478,10 +580,12 @@ def _get_plot_data_inv_isochron_axis(smp: sample, **options):
         'interval': interval,
         'id': 0, 'show_frame': True, 'z_index': 9, 'label_size': label_size, 'title_size': title_size,
         'title': '<sup>39</sup>Ar<sub>K</sub> / <sup>40</sup>Ar<sup>*</sup>', 'name_location': 'middle',
+        'line_width': line_width,
     })
     xAxis.append({
         'extent': [0, 100], 'interval': [], 'id': 1, 'show_frame': False,
         'title': '', 'name_location': 'middle', 'z_index': 0, 'label_size': label_size, 'title_size': title_size,
+        'line_width': 0,
     })
 
     low_limit, up_limit, stick_num, inc = get_axis_scale(data[2])
@@ -507,9 +611,10 @@ def _get_plot_data_inv_isochron_axis(smp: sample, **options):
 
 def _get_plot_data_inv_isochron_series(smp: sample, **options):
     color = options.get('color', 'black')
+    marker_size = options.get('marker_szie', 2)
     xAxis = options.get('xAxis', [{}])
     yAxis = options.get('yAxis', [{}])
-    sigma = options.get('sigma', 1)
+    sigma = options.get('sigma', 2)
     series = []
     age = smp.ApparentAgeValues[2:4]
     ar = smp.DegasValues[20]
@@ -519,22 +624,22 @@ def _get_plot_data_inv_isochron_series(smp: sample, **options):
     set3 = smp.InvIsochronPlot.set3.data
     # set 1
     series.append({
-        'type': 'series.scatter', 'id': f'scatter-{smp.name()}-{get_random_digits()}', 'name': f'scatter-{smp.name()}-{get_random_digits()}',
-        'stroke_color': 'red', 'fill_color': 'red', 'myType': 'scatter', 'size': 3, 'line_width': 0,
+        'type': 'series.scatter', 'id': f'scatter-{smp.name()}-{random_choice()}', 'name': f'scatter-{smp.name()}-{random_choice()}',
+        'stroke_color': colors_map['red'], 'fill_color': colors_map['red80'], 'myType': 'scatter', 'size': marker_size, 'line_width': 0,
         'data': (data[[0, 2], :][:, set1]).transpose().tolist(),
         'axis_index': 0, 'z_index': 99
     })
     # set 2
     series.append({
-        'type': 'series.scatter', 'id': f'scatter-{smp.name()}-{get_random_digits()}', 'name': f'scatter-{smp.name()}-{get_random_digits()}',
-        'stroke_color': 'blue', 'fill_color': 'blue', 'myType': 'scatter', 'size': 3, 'line_width': 0,
+        'type': 'series.scatter', 'id': f'scatter-{smp.name()}-{random_choice()}', 'name': f'scatter-{smp.name()}-{random_choice()}',
+        'stroke_color': colors_map['blue'], 'fill_color': colors_map['blue80'], 'myType': 'scatter', 'size': marker_size, 'line_width': 0,
         'data': (data[[0, 2], :][:, set2]).transpose().tolist(),
         'axis_index': 0, 'z_index': 99
     })
     # set 3
     series.append({
-        'type': 'series.scatter', 'id': f'scatter-{smp.name()}-{get_random_digits()}', 'name': f'scatter-{smp.name()}-{get_random_digits()}',
-        'stroke_color': 'black', 'fill_color': 'white', 'myType': 'scatter', 'size': 3, 'line_width': 0,
+        'type': 'series.scatter', 'id': f'scatter-{smp.name()}-{random_choice()}', 'name': f'scatter-{smp.name()}-{random_choice()}',
+        'stroke_color': 'black', 'fill_color': 'white', 'myType': 'scatter', 'size': marker_size, 'line_width': 0,
         'data': (data[[0, 2], :][:, set3]).transpose().tolist(),
         'axis_index': 0, 'z_index': 0
     })
@@ -548,18 +653,18 @@ def _get_plot_data_inv_isochron_series(smp: sample, **options):
                             (float(xAxis[0]['extent'][1]), float(xAxis[0]['extent'][1]) * smp.Info.results.isochron['figure_3'][index]['m1'] + smp.Info.results.isochron['figure_3'][index]['k']),
             ]
             series.append({
-                'type': 'series.line', 'id': f'line-{smp.name()}-{get_random_digits()}', 'name': f'line-{smp.name()}-{get_random_digits()}',
-                'color': ['red', 'blue'][index], 'fill_color': ['red', 'blue'][index],
-                'line_width': 1.5, 'line_style': 'solid',
+                'type': 'series.line', 'id': f'line-{smp.name()}-{random_choice()}', 'name': f'line-{smp.name()}-{random_choice()}',
+                'color': [colors_map['red'], colors_map['blue']][index], 'fill_color': [colors_map['red'], colors_map['blue']][index],
+                'line_width': 1, 'line_style': 'solid',
                 'data': isochron_data,
                 'axis_index': 0,
             })
             series.append({
-                'type': 'text', 'id': f'text-{smp.name()}-{get_random_digits()}', 'name': f'text-{smp.name()}-{get_random_digits()}',
-                'color': ['red', 'blue'][index], 'fill_color': ['red', 'blue'][index],
-                'text': f"IIA = {smp.Info.results.isochron['figure_3'][index]['age']:.2f} ± {(sigma * smp.Info.results.isochron['figure_3'][index]['s3']):.2f} Ma<r>"
-                        f"[<sup>40</sup>Ar/<sup>36</sup>Ar]<sub>i</sub> = {smp.Info.results.isochron['figure_3'][index]['initial']:.2f} ± {(sigma * smp.Info.results.isochron['figure_3'][index]['sinitial']):.2f}<r>"
-                        f"MSWD = {smp.Info.results.isochron['figure_3'][index]['MSWD']:.2f}, r<sup>2</sup> = {smp.Info.results.isochron['figure_3'][index]['R2']:.4f}<r>",
+                'type': 'text', 'id': f'text-{smp.name()}-{random_choice()}', 'name': f'text-{smp.name()}-{random_choice()}',
+                'color': [colors_map['red'], colors_map['blue']][index], 'fill_color': [colors_map['red'], colors_map['blue']][index],
+                'text': f"IIA = {smp.Info.results.isochron['figure_3'][index]['age']:.2f} ± {(sigma * smp.Info.results.isochron['figure_3'][index]['s2']):.2f} Ma ({sigma}s)<r>"
+                        f"(40Ar/36Ar)0 = {smp.Info.results.isochron['figure_3'][index]['initial']:.2f} ± {(sigma * smp.Info.results.isochron['figure_3'][index]['sinitial']):.2f}<r>"
+                        f"MSWD = {smp.Info.results.isochron['figure_3'][index]['MSWD']:.2f}<r>",
                 'size': title_size,
                 'data': [text.pos],
                 'axis_index': 1,
@@ -568,8 +673,8 @@ def _get_plot_data_inv_isochron_series(smp: sample, **options):
             })
 
     series.append({
-        'type': 'text', 'id': f'text-{smp.name()}-{get_random_digits()}',
-        'name': f'text-{smp.name()}-{get_random_digits()}', 'color': color,
+        'type': 'text', 'id': f'text-{smp.name()}-{random_choice()}',
+        'name': f'text-{smp.name()}-{random_choice()}', 'color': color,
         'text': smp.name(), 'size': title_size,
         'data': [[50, 95]], 'axis_index': 1,
         'h_align': "middle", 'v_align': "center",
@@ -590,7 +695,7 @@ def _get_plot_data_degas_pattern(smp: sample, **options):
     data = np.array([x, y])
     # set 1
     series.append({
-        'type': 'series.scatter', 'id': f'scatter-{smp.name()}-{get_random_digits()}', 'name': f'scatter-{smp.name()}-{get_random_digits()}',
+        'type': 'series.scatter', 'id': f'scatter-{smp.name()}-{random_choice()}', 'name': f'scatter-{smp.name()}-{random_choice()}',
         'stroke_color': color, 'fill_color': 'white', 'myType': 'scatter', 'size': 4, 'line_width': 1,
         'data': data.transpose().tolist(), 'axis_index': 0, 'z_index': 99
     })
@@ -682,7 +787,7 @@ def _get_plot_data_degas_spectra_series(smp: sample, **options):
 
     # set 1
     series.append({
-        'type': 'rect', 'id': f'rect-{smp.name()}-{get_random_digits()}', 'name': f'rect-{smp.name()}-{get_random_digits()}',
+        'type': 'rect', 'id': f'rect-{smp.name()}-{random_choice()}', 'name': f'rect-{smp.name()}-{random_choice()}',
         'color': color, 'myType': 'rect', 'line_width': 1,
         'data': data.transpose().tolist(),
         'axis_index': 0, 'z_index': 99
@@ -739,13 +844,13 @@ def _get_plot_data_degas_curve_series(smp: sample, **options):
 
     # line
     series.append({
-        'type': 'line', 'id': f'line-{smp.name()}-{get_random_digits()}', 'name': f'line-{smp.name()}-{get_random_digits()}',
+        'type': 'line', 'id': f'line-{smp.name()}-{random_choice()}', 'name': f'line-{smp.name()}-{random_choice()}',
         'color': color, 'myType': 'line', 'line_width': 1, 'line_style': 'solid',
         'data': np.array([x, released]).transpose().tolist(),
         'axis_index': 0, 'z_index': 99
     })
     series.append({
-        'type': 'line', 'id': f'line-{smp.name()}-{get_random_digits()}', 'name': f'line-{smp.name()}-{get_random_digits()}',
+        'type': 'line', 'id': f'line-{smp.name()}-{random_choice()}', 'name': f'line-{smp.name()}-{random_choice()}',
         'color': color, 'myType': 'line', 'line_width': 1, 'line_style': 'solid',
         'data': np.array([x, remained]).transpose().tolist(),
         'axis_index': 0, 'z_index': 99
@@ -816,7 +921,7 @@ class WritingWorkbook:
 
         style = xls.add_format(self.default_fmt_prop)
 
-        sigma = int(self.sample.Info.preference['confidenceLevel'])
+        sigma = int(self.sample.Info.preference.confidence_level)
 
         sht_reference = xls.add_worksheet("Reference")  # Data used to plot
         sht_reference.hide_gridlines(2)  # 0 = show grids, 1 = hide print grid, else = hide print and screen grids
@@ -1070,10 +1175,10 @@ class WritingWorkbook:
         weight = self.sample.Info.sample.weight
         J_value = self.sample.TotalParam[67][0]
         J_error = self.sample.TotalParam[68][0] * self.sample.TotalParam[67][0] / 100
-        sigma = self.sample.Info.preference['confidenceLevel']
+        sigma = self.sample.Info.preference.confidence_level
         sequence_type = {"StepLaser": "Laser", "StepFurnace": "Temperature", "StepCrusher": "Drop", }.get(method, "Step Value")
         sequence_unit = self.sample.Info.sample.sequence_unit if self.sample.Info.sample.sequence_unit != "" else "Unit"
-        age_unit = self.sample.Info.preference['ageUnit']
+        age_unit = self.sample.Info.preference.age_unit
         num_step = len(self.sample.SequenceName)
         set1_ratio = [self.sample.Info.results.isochron['figure_3'][0]['initial'], self.sample.Info.results.isochron['figure_2'][0]['initial'], self.sample.TotalParam[116][0]][int(self.sample.TotalParam[115][0])]
         set2_ratio = [self.sample.Info.results.isochron['figure_3'][1]['initial'], self.sample.Info.results.isochron['figure_2'][1]['initial'], self.sample.TotalParam[118][0]][int(self.sample.TotalParam[115][0])]
@@ -1144,7 +1249,7 @@ class WritingWorkbook:
         tga_res = self.sample.Info.results.age_spectra['TGA']
         content.extend([
             [(9 + num_step, 1, 10 + num_step, 1), tga_res['F'], {'num_format': '0.00000'}],
-            [(9 + num_step, 2, 10 + num_step, 2), tga_res['sF'], {'num_format': '0.00000'}],
+            [(9 + num_step, 2, 10 + num_step, 2), tga_res['sF'] * sigma, {'num_format': '0.00000'}],
             [(9 + num_step, 3, 10 + num_step, 3), tga_res['age'], {'num_format': '0.00'}],
             [(9 + num_step, 4), tga_res['s1'] * sigma, {'num_format': '± 0.00', 'align': 'left'}],
             [(9 + num_step, 5), tga_res['s2'] * sigma, {'num_format': '± 0.00', 'align': 'left'}],
@@ -1164,7 +1269,6 @@ class WritingWorkbook:
         ]:
             for index, _ in enumerate(['Set 1', 'Set 2']):
                 ar39[index] = res[index].get('Ar39', ar39[index] * 100) / 100
-                print(res[index])
                 try:
                     content.extend([
                         [(row + num_step, 0, row + 1 + num_step, 0), _, {'bold': 1, 'align': 'center'}],
@@ -1205,20 +1309,36 @@ class WritingWorkbook:
 
     def write_sht_table(self, sht_name, prop_name, sht_type, row, col, _, smp_attr_name, header_name, style, xls, sigma=1):
         sht = xls.add_worksheet(sht_name)
+        num_step = len(self.sample.SequenceName)
         data = arr.transpose(getattr(self.sample, smp_attr_name, None).data)
         sht.hide_gridlines(2)  # 0 = show grids, 1 = hide print grid, else = hide print and screen grids
         sht.hide()  # default hidden table sheet
         sht.set_column(0, len(data), width=12)  # column width
         header = getattr(sample, header_name)
         header = list(map(lambda each: each if "σ" not in each else each.replace('1', str(sigma)) if str(sigma) not in each else each.replace('2', str(sigma)), header))
-        sht.write_row(row=row - 1, col=col, data=header, cell_format=style)
-        for index, col_data in enumerate(data):
-            if "σ" in header[col]:
-                col_data = list(map(lambda each: each * sigma, col_data))
-            res = sht.write_column(row=row, col=col, data=col_data, cell_format=style)
-            if res:
-                raise ValueError(res)
-            col += 1
+
+        content = [
+            [(0, 0), f"{sht_name}", {'bold': 1, 'top': 1, 'align': 'left'}],
+            *[[(1, col, 2, col), each, {'bold': 1, 'top': 1, 'bottom': 6}] for col, each in enumerate(header)],
+            *[[(3, col, 1), each if "σ" not in header[col] else list(map(lambda _: _ * sigma, each)), {}] for col, each in enumerate(data)],
+            [(3 + num_step, 0, 0), [''] * len(data), {'bold': 1, 'top': 1}],
+        ]
+
+        for pos, value, _prop in content:
+            prop = self.default_fmt_prop.copy()
+            prop.update(_prop)
+            fmt = Format(prop, xls.xf_format_indices, xls.dxf_format_indices)
+            xls.formats.append(fmt)
+            if isinstance(value, (list, np.ndarray)) and len(pos) == 3:
+                value = [None if isinstance(v, (float, int)) and np.isnan(v) else v for v in value]
+                [sht.write_row, sht.write_column][pos[2]](*pos[:2], value, fmt)
+            elif len(pos) == 2:
+                isnumeric = isinstance(value, (float, int)) and not np.isnan(value) and not np.isinf(value)
+                [sht.write_string, sht.write_number][isnumeric](*pos, value if isnumeric else str(value), fmt)
+            elif len(pos) == 4:
+                isnumeric = isinstance(value, (float, int)) and not np.isnan(value) and not np.isinf(value)
+                sht.merge_range(*pos, value if isnumeric else str(value), fmt)
+
 
     def write_sht_chart(self, sht_name, prop_name, sht_type, row, col, _, smp_attr_name, header_name, style, xls, start_row, total_rows):
         sht = xls.add_chartsheet(sht_name)
@@ -1243,7 +1363,7 @@ class WritingWorkbook:
                 f"I{start_row}:I{(total_rows + 1) * 2 + start_row - 1}",
             ]
             axis_range = [figure.xaxis.min, figure.xaxis.max, figure.yaxis.min, figure.yaxis.max]
-            self.get_chart_age_spectra(xls, sht, data_area, axis_range, age_unit=self.sample.Info.preference['ageUnit'])
+            self.get_chart_age_spectra(xls, sht, data_area, axis_range, age_unit=self.sample.Info.preference.age_unit)
         elif "normal_isochron" in prop_name.lower():
             data_area = [
                 f"O{start_row}:O{num_set1 + start_row - 1}", f"P{start_row}:P{num_set1 + start_row - 1}",
@@ -1839,7 +1959,7 @@ class CreatePDF:
         yaxis_max = float(yaxis.max)
 
         plot_scale = (xaxis_min, xaxis_max, yaxis_min, yaxis_max)
-        colors = ['red', 'color']
+        colors = [colors_map['red'], 'color']
 
         # create a canvas
         cv = pm.Canvas(width=17, height=12, unit="cm", show_frame=True, clip_outside_plot_areas=False)
@@ -1978,10 +2098,10 @@ class CreatePDF:
         for index in range(len(data) - 1):
             pt.line(start=(data[index][0], data[index][1]), end=(data[index + 1][0], data[index + 1][1]),
                     width=widths[0], line_style=styles[0], color=colors[0],
-                    clip=True, line_caps="square", z_index=9)
+                    clip=True, line_caps="none", z_index=9)
             pt.line(start=(data[index][0], data[index][2]), end=(data[index + 1][0], data[index + 1][2]),
                     width=widths[1], line_style=styles[1], color=colors[1],
-                    clip=True, line_caps="square", z_index=9)
+                    clip=True, line_caps="none", z_index=9)
 
         colors = [
             [self.color_rgb_normalized(self.color_hex_to_rgb(plot.line3.color)),
@@ -2075,8 +2195,6 @@ class CreatePDF:
         yaxis_max = float(yaxis.max)
         plot_scale = (xaxis_min, xaxis_max, yaxis_min, yaxis_max)
 
-        colors = ['red', 'color']
-
         # data
         data = plot.data  # 36a, 37ca, 38cl, 39k, 40r, 36, 37, 38, 39, 40