petal-qc 0.0.0__py3-none-any.whl

petal_qc/metrology/flatness4nigel.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+
+import numpy as np
+import time
+from scipy.spatial import Delaunay
+from scipy.spatial import ConvexHull
+
+
+def flatness_LSPL(M):
+    """Compute flatness according to least squares reference plane method.
+
+    ISO/TS 12781-1
+
+    Args:
+        M (np.ndarray): The data nx3 array
+
+    Return
+        (float) - the computed flatness
+    """
+
+    # calculate the center of mass and translate all points
+    com = np.sum(M, axis=0) / len(M)
+    q = M - com
+
+    # calculate 3x3 matrix. The inner product returns total sum of 3x3 matrix
+    Q = np.dot(q.T, q)
+
+    # Calculate eigenvalues and eigenvectors
+    la, vectors = np.linalg.eig(Q)
+
+    # Extract the eigenvector of the minimum eigenvalue
+    n = vectors.T[np.argmin(la)]
+
+    e = np.dot(q, n)
+
+    eplus = abs(np.amax(e[np.where(e > 0)]))
+    eminus = abs(np.amin(e[np.where(e < 0)]))
+
+    flatness = eplus + eminus
+    return flatness
+
+
+def flatness_conhull(M):
+    """Compute (MZPL) flatness by convex hull algorithm.
+
+    Robust Convex Hull-based Algoritm for Straightness and Flatness
+    Determination in Coordinate Measuring (Gyula Hermann)
+
+    Args:
+        M: point array of size (npoints, ndim)
+
+    Returns
+    -------
+        flatness - the computed flatness
+
+    """
+    X = M[:, 0]
+    Y = M[:, 1]
+    Z = M[:, 2]
+    ch = Delaunay(M).convex_hull
+
+    N = ch.shape[0]
+    max_dis_local = np.zeros([N, 1])
+    for i in range(0, N):
+        P1 = np.array([X[ch[i, 0]], Y[ch[i, 0]], Z[ch[i, 0]]])
+        P2 = np.array([X[ch[i, 1]], Y[ch[i, 1]], Z[ch[i, 1]]])
+        P3 = np.array([X[ch[i, 2]], Y[ch[i, 2]], Z[ch[i, 2]]])
+
+        normal = np.cross(P1-P2, P1-P3)
+
+        D = -normal[0] * P3[0] - normal[1] * P3[1] - normal[2] * P3[2]
+
+        plane_0 = np.array([normal[0], normal[1], normal[2], D])
+        plane = plane_0 / np.sqrt(np.sum(plane_0**2))
+
+        dis = np.abs(plane[0] * X[:] + plane[1] * Y[:] + plane[2] * Z[:] +
+                     plane[3]) / np.sqrt(plane[0]**2 + plane[1]**2 + plane[2]**2)
+
+        max_dis_local[i] = np.max(dis)
+
+    return np.min(max_dis_local)
+
+
+def flatness_conhullN(M):
+    """Compute (MZPL) flatness by convex hull algorithm.
+
+    Robust Convex Hull-based Algoritm for Straightness and Flatness
+    Determination in Coordinate Measuring (Gyula Hermann)
+
+    Args:
+        M: point array of size (npoints, ndim)
+
+    Returns
+    -------
+        flatness - the computed flatness
+
+    """
+    X = M[:, 0]
+    Y = M[:, 1]
+    Z = M[:, 2]
+    max_dis_local = []
+    hull = ConvexHull(M, incremental=False, qhull_options=None)
+    for plane in hull.equations:
+        dis = np.abs(plane[0] * X[:] + plane[1] * Y[:] + plane[2] * Z[:] + plane[3])
+        max_dis_local.append(np.max(dis))
+
+    return np.min(max_dis_local)
+
+
+if __name__ == "__main__":
+    import argparse
+    import sys
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('files', nargs='*', help="Input files")
+
+    options = parser.parse_args()
+    if len(options.files) == 0:
+        print(sys.argv[0])
+        print("I need an input file")
+        sys.exit()
+
+    try:
+        data = np.loadtxt(options.files[0], unpack=False, skiprows=1, delimiter=',')
+
+    except Exception as E:
+        print("Could not open input file.")
+        print(E)
+        sys.exit(1)
+
+    flatness = flatness_LSPL(data)
+    print("LSPL: {:.4f}".format(flatness))
+
+    flatness = flatness_conhull(data)
+    print("convex-hull: {:.4f}".format(flatness))
+
+    flatness = flatness_conhullN(data)
+    print("convex-hullN: {:.4f}".format(flatness))
+
+    N = 100
+    tic = time.perf_counter()
+    for i in range(N):
+        flatness = flatness_LSPL(data)
+    toc = time.perf_counter()
+    print("LSPF: {:.4f}".format((toc-tic)/N))
+    
+    tic = time.perf_counter()
+    for i in range(N):
+        flatness = flatness_conhull(data)
+    toc = time.perf_counter()
+    print("Delauney: {:.4f}".format((toc-tic)/N))
+    
+    tic = time.perf_counter()
+    for i in range(N):
+        flatness = flatness_conhullN(data)
+    toc = time.perf_counter()
+    print("ConHull: {:.4f}".format((toc-tic)/N))

petal_qc/metrology/gtkutils.py

@@ -0,0 +1,120 @@
+import time
+import gi
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk, GObject, Gio, GLib
+
+
+
+def complain(main_title, second_text="", parent=None):
+    """Open an error dialog.
+
+    Args:
+        main_title: Main text in window
+        second_text: Second text
+        parent: dialog parent
+
+    """
+    dialog = Gtk.MessageDialog(
+        transient_for=parent,
+        flags=0,
+        message_type=Gtk.MessageType.ERROR,
+        buttons=Gtk.ButtonsType.OK,
+        text=main_title,
+    )
+    dialog.format_secondary_text(second_text)
+    dialog.run()
+    dialog.destroy()
+
+
+def ask_for_confirmation(main_title, second_text, parent=None):
+    """Ask for action cofirmation.
+
+    Args:
+        main_title: Main title in the message window
+        second_text: Secondary text in the message widow
+        parent (optional): The parent window. Defaults to None.
+
+    Return:
+        OK: True if OK button clicked.
+
+    """
+    dialog = Gtk.MessageDialog(
+        transient_for=parent,
+        flags=0,
+        message_type=Gtk.MessageType.INFO,
+        text=main_title
+    )
+    dialog.add_buttons(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OK, Gtk.ResponseType.OK)
+    dialog.format_secondary_text(second_text)
+    out = dialog.run()
+    dialog.destroy()
+    return (out == Gtk.ResponseType.OK)
+
+
+    box.pack_start(btn, True, False, 0)
+
+    return btn
+
+
+class MessagePanel(object):
+    """Encapsulates a TExtView object to show messages."""
+
+    def __init__(self, size=100):
+        """Initializarion."""
+        self.frame = None
+        self.text_view = Gtk.TextView()
+        self.textbuffer = self.text_view.get_buffer()
+        self.__create_message_panel(size)
+
+    def __create_message_panel(self, size):
+        """Creates a message panel within a frame.
+
+        Args:
+            size: size of the panel
+
+        Returns:
+            Gtk.TextBuffer, Gtk.Frame
+        """
+        frame = Gtk.Frame()
+        frame.set_shadow_type(Gtk.ShadowType.IN)
+
+        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
+        box.set_size_request(-1, size)
+        frame.add(box)
+
+        # The title for the tet view
+        box.pack_start(Gtk.Label(label="Messages"), False, True, 0)
+
+        # A scroll window with the text view
+        scrolled = Gtk.ScrolledWindow()
+        scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
+        scrolled.add(self.text_view)
+        box.pack_start(scrolled, True, True, 0)
+        self.frame = frame
+
+    def scroll_to_end(self):
+        """Scrolls text view to end."""
+        end = self.textbuffer.get_end_iter()
+        self.text_view.scroll_to_iter(end, 0, False, 0, 0)
+
+    def write_message(self, text, write_date=True):
+        """Writes text to Text Viewer."""
+        nlines = self.textbuffer.get_line_count()
+        if nlines > 100:
+            start = self.textbuffer.get_iter_at_line(0)
+            end = self.textbuffer.get_iter_at_line(75)
+            self.textbuffer.delete(start, end)
+
+        end = self.textbuffer.get_end_iter()
+        if write_date:
+            msg = "[{}]  {}".format(time.strftime("%d/%m/%y %T"), text)
+        else:
+            msg = text
+
+        self.textbuffer.insert(end, msg)
+        GLib.idle_add(self.scroll_to_end)
+        
+    def write(self, txt):
+        """A write method."""
+        self.write_message(txt, write_date=False)
+

petal_qc/metrology/petal_flatness.py

@@ -0,0 +1,353 @@
+#!/usr/bin/env python3
+"""Petal flatness.
+
+This file contains the methods to produce the metrology reports of the petal
+core metrology survey.
+
+"""
+import math
+import os
+import sys
+import tempfile
+import traceback
+from argparse import Action
+from argparse import ArgumentParser
+
+import petal_qc.utils.docx_utils as docx_utils
+import matplotlib.pyplot as plt
+import numpy as np
+
+from petal_qc.metrology import DataFile
+from petal_qc.utils.fit_utils import draw_best_fit
+from petal_qc.utils.fit_utils import fit_gaussian
+from petal_qc.utils.Geometry import fit_plane
+from petal_qc.utils.Geometry import flatness_conhull, flatness_LSPL
+from petal_qc.utils.Geometry import project_to_plane
+
+from .analyze_locking_points import analyze_locking_point_data, locking_point_positions
+from .analyze_locking_points import remove_outliers
+from .Cluster import cluster_points
+from .show_data_file import show_data, TOP_VIEW
+
+figure_width = 14
+
+
+class CommaSeparatedListAction(Action):
+    """Create a list from the comma sepparated numbers at imput."""
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        """The actual action."""
+        value = np.array(list(map(float, values.split(','))), dtype='float64')
+        if value.shape[0] < 3:
+            raise Exception("{} needs a 3D vector".format(self.dest))
+
+        setattr(namespace, self.dest, value)
+
+
+def plot_sensor(Spoints, ax, marker='o', cmap='magma'):
+    """Plot the points given in a scatter plot."""
+    ax.scatter(Spoints[:, 0], Spoints[:, 1], Spoints[:, 2],
+               c=Spoints[:, 2], cmap=cmap, marker=marker,
+               linewidth=0.5)
+
+
+def sensor_flatness(data, name="Sensor", prefix=None, nbins=50, do_fit=False, do_3d=False, save=False, document=None):
+    """Show Sensor flatness plot.
+
+    Args:
+    ----
+        data: the data array
+        name: name of the sensor
+        nbins: number of bins in histogram
+        prefix: prefix to be added to the name if not None.
+        save: Save plot if True
+        document: insert figure in document if not None.
+
+    """
+    width = 0.0
+    ncol = 1
+    out, V, M, L = fit_plane(data)
+    Z = out[:, 2]
+
+    fig = plt.figure(figsize=[12, 6])
+    fig.suptitle(name)
+    fig.subplots_adjust(left=0.05, right=0.95)
+    if do_3d:
+        ncol = 2
+        ax = fig.add_subplot(1, 2, 1, projection='3d')
+        # ax.view_init(azim=-90, elev=90)
+        ax.set_title("plane of min Z variance")
+        surf = ax.scatter(out[:, 0], out[:, 1], Z, c=Z, marker='.', cmap=plt.cm.jet)
+        # surf = ax.plot_trisurf(out[:, 0], out[:, 1], Z, cmap=plt.cm.jet, edgecolor="black", linewidths=0.2)
+        ax.set_xlabel("X")
+        ax.set_ylabel("Y")
+        ax.set_zlabel("Z")
+        fig.colorbar(surf, shrink=0.5, aspect=5, location='left')
+
+    ax = fig.add_subplot(1, ncol, ncol)
+    n, bins, *_ = ax.hist(Z, bins=nbins)
+    if do_fit:
+        step = 0.5 * (bins[1] - bins[0])
+        X = bins[:-1] + step
+        result, legend = fit_gaussian(n, X, np.mean(Z), width=np.std(Z))
+        ax.legend([legend], loc=1)
+        draw_best_fit(ax, result, bins)
+        rms = result.best_values['sigma']
+        center = result.best_values['center']
+        v1 = center - 3.5*rms
+        v2 = center + 3.5*rms
+        width = v2 - v1
+        ax.axvspan(v1, v2, alpha=0.20, facecolor='g')
+        ax.set_title("Z dispersion: {:.3f}".format(width))
+        # plt.yscale('log')
+        print("{}: rms: {:.3f} 7xRMS {:.3f}".format(name, rms, v2-v1))
+
+    out_file = None
+    if save is True:
+        if prefix is None:
+            out_file = "{}.png".format(name)
+        else:
+            out_file = "{}-{}.png".format(prefix, name)
+
+        plt.savefig(out_file, dpi=300)
+
+    if document:
+        document.add_picture(fig, True, figure_width, caption="{} planarity.".format(name))
+        plt.close(fig)
+
+    return width
+
+
+def petal_flatness(orig_data, options, document=None):
+    """Compute the petal flatness in the different sensor areas.
+
+    Args:
+    ----
+        filename: CSV file with metrology values array([npoints, 3])
+        options: parser options (see entry)
+        document: docx document.
+
+    """
+    # SHow raw data
+    show_petal_points(orig_data, "Original Input Data")
+
+    # Try to remove locator points and get the plane
+    indx = remove_outliers(orig_data[:, 2])
+    M, TM, avg, *_ = fit_plane(orig_data[indx], use_average=7)
+
+    # project all data to the plane
+    M = project_to_plane(orig_data, TM, [0., 0., avg[2]])
+    Zmean = np.mean(M[indx, 2])
+    M[:, 2] -= Zmean
+    Z = M[:, 2]
+
+    show_petal_points(M, "On Petal plane.")
+
+    # group points by sensors.
+    sensor_dict = {0: "R0", 10: "R1", 20: "R2", 30: "R3_0", 31: "R3_1", 40: "R4_0", 41: "R4_1", 50: "R5_0", 51: "R5_1"}
+    sensors, *_ = group_by_sensors(M, options.is_front, False)
+    all_data = np.vstack(list(sensors.values()))
+
+    fig = show_data(all_data, "All points in core", view=TOP_VIEW, surf=False)
+
+    if document:
+        document.add_heading('All points', level=1)
+        document.add_picture(fig, True, 14, caption="All points in Petal.")
+        plt.close(fig)
+
+    #
+    # Add the tables to the document
+    #
+    # flatness_func = flatness_conhull
+    flatness_func = flatness_LSPL
+    F = {}
+    for key, val in sensors.items():
+        F[key] = flatness_func(val)
+
+    flatness_all_sensor_area = flatness_func(all_data)
+
+    outF = [flatness_all_sensor_area, ]
+    print("Is front ? {}".format(options.is_front))
+    print("Flatness:")
+    for i in range(6):
+        if i < 3:
+            id = 10*i
+            lbl = sensor_dict[id]
+            print("{}: {:.3f}".format(lbl, F[id]))
+            outF.append(F[id])
+        else:
+            ids = [10*i, 10*i+1]
+            lbls = [sensor_dict[i] for i in ids]
+            values = [F[id] for id in ids]
+            outF.extend(values)
+            print("{}: {:.3f}  {}: {:.3f}".format(lbls[0], values[0], lbls[1], values[1]))
+
+    print("All sensor area: {:.3f}".format(flatness_all_sensor_area))
+
+    # Add table in document
+    if document:
+        document.add_heading('Petal flatness (LSPL)', level=1)
+        table = document.insert_table(rows=1, cols=3, caption="Flatness (LSPL)")
+        table.style = document.styles['Table Grid']
+
+        # populate header row --------
+        heading_cells = table.rows[0].cells
+        heading_cells[0].text = ""
+        heading_cells[1].text = "Flatness (µm)"
+        a = table.cell(0, 1)
+        b = table.cell(0, 2)
+        A = a.merge(b)
+
+        heading_cells = table.add_row().cells
+        heading_cells[0].text = "Area"
+        heading_cells[1].text = "S0"
+        heading_cells[2].text = "S1"
+
+        for i in range(6):
+            cell = table.add_row().cells
+            cell[0].text = "R{}".format(i)
+            cell[1].text = "{:.4f}".format(F[10*i]*1000)
+            if i > 2:
+                cell[2].text = "{:.4f}".format(F[10*i+1]*1000)
+
+        # add allsensor area
+        cell = table.add_row().cells
+        cell[0].text = "All sensor area"
+        cell[1].text = "{:.4f}".format(flatness_all_sensor_area)
+
+    return TM, avg, Zmean, outF
+
+
+def show_petal_points(orig_data, title):
+    """Show the given points."""
+    fig = plt.figure(figsize=[5, 5])
+    fig.suptitle(title)
+    ax = fig.add_subplot(2, 1, 1, projection='3d')
+    ax.view_init(azim=-90, elev=90)
+    Z = orig_data[:, 2]
+    ax.scatter(orig_data[:, 0], orig_data[:, 1], Z, c=Z, cmap='viridis', linewidth=0.5)
+    ax = fig.add_subplot(2, 1, 2)
+    n, bins, *_ = ax.hist(Z, bins=100)
+    plt.yscale('log')
+
+
+sensorR = (
+    (384.5, 488.423), (489.823, 574.194), (575.594, 637.209),
+    (638.609, 755.501), (756.901, 866.062), (867.462, 967.785)
+)
+
+
+def get_iring(P, is_front):
+    """REturn ring number
+
+    Args:
+    ----
+        P (3D point): A 3D point o nthe petal surface
+        is_front: True if front side. Otehrwse false.
+
+    Returns:
+        int: The ring (10*iring + side)
+
+    """
+    R = np.sqrt(np.sum(P[0:2]**2))
+    i = 0
+    for ri, ro in sensorR:
+        if ri <= R and R <= ro:
+            if i < 3:
+                side = 0
+            else:
+                side = 0 if P[0] > 0 else 1
+
+            return 10*i + side
+
+        i = i + 1
+
+    return -1
+
+
+def group_by_sensors(Min, is_front=True, remove_outliers=False):
+    """Groups data points by sensors."""
+    # Now move in Y to be on the ATLAS reference
+    M = np.array(Min)
+    M[:, 1] = M[:, 1] + 382
+
+    other = []
+    sensors = {}
+
+    for i in range(0, M.shape[0]):
+        P = M[i, :]
+        iring = get_iring(P, is_front)
+        if iring < 0:
+            other.append(P)
+
+        else:
+            sensors.setdefault(iring, []).append(P)
+
+    if remove_outliers:
+        for key, val in sensors.items():
+            if remove_outliers:
+                sensors[key] = remove_outliers(sensors[key][:, 2], 0.075)
+
+    return sensors, np.array(other)
+
+
+def do_petal_flatness(filename, options):
+    """Calls petal_flatness
+
+    Args:
+    ----
+        filename (): Data file name
+        options (): Options
+    """
+    orig_data = DataFile.read(filename, label=options.label, type=options.type)
+    if orig_data is None:
+        print("Input file not found.")
+        return
+
+    # Open the output document if a title is given in the options.
+    document = docx_utils.Document()
+    document.add_page_numbers()
+    document.styles['Normal'].font.name = "Calibri"
+    if options.title:
+        document.add_heading(options.title, 0)
+
+    petal_flatness(orig_data, options, document=document)
+
+    document.save(options.out)
+
+
+if __name__ == "__main__":
+    parser = ArgumentParser()
+    parser.add_argument('files', nargs='*', help="Input files")
+    parser.add_argument("--prefix", dest='prefix', default=None)
+    parser.add_argument("--save", dest='save', action="store_true", default=False)
+    parser.add_argument("--front", dest='is_front', action="store_true", default=True)
+    parser.add_argument("--back", dest='is_front', action="store_false", default=True)
+    parser.add_argument("--bottom-lp", dest='bLP', action=CommaSeparatedListAction, default=None,
+                        help="Bottom locking point fiducial coordinates")
+    parser.add_argument("--upper-lp", dest='uLP', action=CommaSeparatedListAction, default=None,
+                        help="upper locking point fiducials coordinates")
+    parser.add_argument("--out", dest="out", default="petal_flatness.docx",
+                        type=str, help="The output fiel name")
+    parser.add_argument("--title", dest="title", default=None,
+                        type=str, help="Document title")
+    parser.add_argument("--nbins", dest="nbins", default=50,
+                        type=int, help="Number of bins")
+
+    # This is to convert a CMM file
+    parser.add_argument("--label", default="\\w+", help="The label to select")
+    parser.add_argument("--type", default="Punto", help="The class to select")
+
+    options = parser.parse_args()
+    if len(options.files) == 0:
+        print(sys.argv[0])
+        print("I need an input file")
+        sys.exit()
+
+    try:
+        do_petal_flatness(options.files[0], options)
+
+    except Exception:
+        print(traceback.format_exc())
+
+    plt.show()