petal-qc 0.0.0__py3-none-any.whl

petal_qc/metrology/show_data_file.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""Show data file."""
+import sys
+from argparse import ArgumentParser
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from petal_qc.metrology import DataFile
+from petal_qc.utils.Geometry import fit_plane
+from petal_qc.utils.Geometry import project_to_plane
+from petal_qc.utils.Geometry import remove_outliers_indx
+
+
+DEFAULT_VIEW, TOP_VIEW, FRONT_VIEW = range(0, 3)
+
+
+def show_data(data, title, view=DEFAULT_VIEW, nbins=50, out_file=None, log_axis=False, surf=False, color_bar=True):
+    """Show the data.
+
+    PLot a 3D scatter and the Z distribution.
+    """
+    fig = plt.figure(figsize=[10, 5])
+    fig.suptitle(title)
+    fig.subplots_adjust(left=0.0, right=1.)
+    ax = fig.add_subplot(1, 2, 1, projection='3d')
+    if view == TOP_VIEW:
+        ax.view_init(azim=-90, elev=90)
+    elif view == FRONT_VIEW:
+        ax.view_init(azim=-90, elev=0)
+
+    Z = data[:, 2]
+    if surf:
+        _surf = ax.plot_trisurf(data[:, 0], data[:, 1], Z, cmap=plt.cm.jet, edgecolor="black", linewidths=0.2)   
+    else:
+        _surf = ax.scatter(data[:, 0], data[:, 1], Z, c=Z, marker='.', cmap=plt.cm.jet)
+    
+    ax.set_xlabel("X")
+    ax.set_ylabel("Y")
+    ax.set_zlabel("Z")
+    
+    if color_bar:
+        fig.colorbar(_surf, shrink=0.5, aspect=5, location="left")
+
+    ax = fig.add_subplot(1, 2, 2)
+    n, *_ = ax.hist(Z, bins=nbins)
+    if log_axis:
+        plt.yscale("log")
+
+    if out_file is not None:
+        plt.savefig(out_file, dpi=300)
+
+    return fig
+
+
+def show_data_file(fnam, options):
+    """Plot points in data file."""
+    data = DataFile.read(fnam, label=options.label, type=options.type)
+
+    if options.outliers:
+        indx = remove_outliers_indx(data[:, 2])
+        data = data[indx]
+
+    if options.fit_plane:
+        data, *_ = fit_plane(data)
+
+    # the plane
+    if options.zplane != sys.float_info.max:
+        zd = data[:, 2]
+        cond = np.where((abs(zd-options.zplane) < options.splane))
+        plane, V, M, L = fit_plane(data[cond])
+        data = project_to_plane(data, V, M)
+        show_data(plane, "{} - plane".format(fnam.name))
+
+    show_data(data, fnam.name, log_axis=options.log)
+
+    if options.fit:
+        zd = data[:, 2]
+        indx = np.where((abs(zd-options.zfit) < options.sfit))[0]
+        Y = data[indx, 2]
+        X = data[indx, 0:2]
+        coeff = np.polynomial.chebyshev.chebfit(X, Y, 2)
+        print(coeff)
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    parser = ArgumentParser()
+    parser.add_argument('files', nargs='*', help="Input files")
+    parser.add_argument("--Z-plane", dest='zplane', type=float,
+                        default=sys.float_info.max, help="Estimated value plate Z plane")
+    parser.add_argument("--W-plane", dest='splane', type=float,
+                        default=0.2, help="Estimated width in Z pf points in plale")
+    parser.add_argument("--fit", dest='fit', action="store_true", default=False)
+    parser.add_argument("--fit-plane", dest='fit_plane', action="store_true", default=False,
+                        help="If set, make first a plane fit projection.")
+    parser.add_argument("--log", dest='log', action="store_true", default=False, help="Log Y axis")
+
+    parser.add_argument("--Z-fit", dest='zfit', type=float,
+                        default=sys.float_info.max, help="Estimated value plate Z plane")
+    parser.add_argument("--W-fit", dest='sfit', type=float,
+                        default=0.2, help="Estimated width in Z pf points in plale")
+    parser.add_argument("--remove-outliers", dest="outliers",
+                        help="Remove Outliers", default=False, action="store_true")
+
+    # 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("I need an input file")
+        sys.exit()
+
+    fnam = Path(options.files[0]).expanduser().resolve()
+    show_data_file(fnam, options)

petal_qc/metrology/testSummary.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+"""Read JSon files an produces a summary."""
+
+import sys
+import json
+from pathlib import Path
+
+
+def testSummary(files, options):
+    """PRoduces the summary."""
+    ofile = open(Path(options.out).expanduser().resolve(), "w")
+    for i, ifile in enumerate(files):
+        P = Path(ifile).expanduser().resolve()
+        ofile.write(P.stem + '\n')
+
+        with open(P, "r") as inp:
+            Js = json.load(inp)
+
+            for D in Js["defects"]:
+                ofile.write("{}: {}\n".format(D["name"], D["description"]))
+
+            ofile.write("\n")
+
+
+if __name__ == "__main__":
+    from argparse import ArgumentParser
+    parser = ArgumentParser()
+    parser.add_argument('files', nargs='*', help="Input files")
+    parser.add_argument("--out", default="testSummary.txt")
+
+    options = parser.parse_args()
+    if len(options.files) == 0:
+        print(sys.argv[0])
+        print("I need an input file")
+        sys.exit()
+
+    testSummary(options.files, options)

petal_qc/metrology/test_paralelism.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""Test Paralelism."""
+import sys
+import traceback
+from argparse import ArgumentParser
+from pathlib import Path
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+import DataFile
+from analyze_locking_points import analyze_locking_point_data
+
+
+def do_paralelism(ifile, options):
+    """Calculate paralelism locator-core
+
+    Args:
+    ----
+        files (): Input files
+        options (): Options.
+
+    """
+    ifile = Path(ifile).expanduser().resolve()
+    if not ifile.exists():
+        print("input file {} does not exist.".format(ifile))
+        return
+
+    # Do petal flatness analysis
+    Zmean = 0
+    if options.desy:
+        flatness_data = DataFile.read(ifile, "PetalPlane")
+    else:
+        flatness_data = DataFile.read(ifile, r"Punto[-|Vision-]\w", "Punto")
+        Zmean = np.mean(flatness_data[:, 2])
+        flatness_data -= Zmean
+
+    # Do locator flatness analysis
+    TM = None  # TODO: fix this
+    if options.desy:
+        locator_data = DataFile.read(ifile, ".*_FineFlatness")
+    else:
+        locator_data = DataFile.read(ifile, "PuntoLocator", "Punto")
+        locator_data -= Zmean
+
+    data = np.concatenate((flatness_data, locator_data))
+    out = analyze_locking_point_data(data, nbins=options.nbins, cut=4, plane_fit=True)
+
+    for key, val in out.items():
+        print("{:10} -> {}".format(key, val))
+
+
+if __name__ == "__main__":
+    parser = ArgumentParser()
+    parser.add_argument('files', nargs='*', help="Input files")
+    parser.add_argument("--desy", dest='desy', action="store_true", default=False)
+    parser.add_argument("--nbins", dest="nbins", default=25,
+                        type=int, help="Number of bins")
+
+    options = parser.parse_args()
+    if len(options.files) == 0:
+        print(sys.argv[0])
+        print("I need an input file")
+        sys.exit()
+
+    try:
+        do_paralelism(options.files[0], options)
+        plt.show()
+        
+    except Exception:
+        print(traceback.format_exc())

petal_qc/thermal/CSVImage.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""Get Thenal Image from CSV file."""
+import datetime
+import sys
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+class CSVImage(object):
+    """Read an image from CSV file."""
+
+    def __init__(self, ifile):
+        """Initialize."""
+        config = open(ifile, "rb")
+        in_data = False
+        i = 0
+        for line in config:
+            if not in_data:
+                if b'ImageWidth' in line:
+                    ip = line.find(b'=')+1
+                    self.width = int(line[ip:])
+
+                elif b'ImageHeight' in line:
+                    ip = line.find(b'=')+1
+                    self.height = int(line[ip:])
+
+                elif b'RecDate' in line:
+                    recDate = line[line.find(b'=')+1:].strip()
+
+                elif b'RecTime' in line:
+                    recTime = line[line.find(b'=')+1:].strip()
+
+                elif b'[Data]' in line:
+                    recDate = recDate + b' ' + recTime
+                    self.timestamp = datetime.datetime.strptime(recDate.decode('ascii'), "%d.%m.%Y %H:%M:%S", )
+                    self.image = np.zeros([self.height, self.width])
+                    in_data = True
+
+            else:
+                if len(line):
+                    numbers = line.replace(b',', b'.').split(b';')
+                    row = np.array([float(x) for x in numbers])
+                    self.image[i, :] = row
+                    i = i + 1
+
+        self.image = np.flipud(self.image)
+
+    def get_data(self):
+        """Return the image."""
+        return self.image
+
+
+if __name__ == "__main__":
+    try:
+        fnam = sys.argv[1]
+    except IndexError:
+        print("I need an input file")
+        # sys.exit()
+        fnam = "/private/tmp/minus35.csv"
+
+    img = CSVImage(fnam)
+    print("{}x{}\n".format(img.width, img.height))
+    fig = plt.figure(figsize=(img.width/128, img.height/128))
+    fig.suptitle("CSVimage")
+    plt.imshow(img.get_data(), origin='lower', cmap="jet")
+    plt.colorbar()
+    plt.tight_layout()
+    plt.show()

petal_qc/thermal/DebugPlot.py

@@ -0,0 +1,76 @@
+#!/usr/bin/envp python3
+"""Class encapsulating debug plots."""
+import matplotlib.pyplot as plt
+
+
+class DebugPlot(object):
+    """Handles debugging figures and plots."""
+
+    def __init__(self):
+        """Initialization."""
+        self.ax = {}
+        self.fig = {}
+        n_fig = 0
+
+    def setup_debug(self, f_id, nrow=1, ncol=1, is_3d=False, fig_kw={}):
+        """Prepare debug figure with given identifier.
+
+        Args:
+        ----
+            f_id (): Identifier. Use it later to get the figure associated.
+            nrow (int, optional): Number of rows. Defaults to 1.
+            ncol (int, optional): Number of columns. Defaults to 1.
+            is_3d (boolean): if True prepares a 3D figure.
+            fig_kw: rest of keywords for plt.subplots or figure.
+
+        """
+        if f_id not in self.ax:
+            if is_3d:
+                fig = plt.figure(tight_layout=True, **fig_kw)
+                ax = fig.add_subplot(1, 1, 1, projection='3d')
+            else:
+                fig, ax = plt.subplots(nrow, ncol, tight_layout=True, **fig_kw)
+
+            self.ax[f_id] = ax
+            self.fig[f_id] = fig
+
+    def get_ax(self, f_id):
+        """Return the axes associated to f_id."""
+        return self.ax[f_id]
+
+    def get_fig(self, f_id):
+        """Return the Figure associated to f_id."""
+        return self.fig[f_id]
+
+    def plot(self, f_id, *args):
+        """Plot in axes associated to f_id."""
+        if f_id not in self.ax:
+            return
+
+        self.ax[f_id].clear()
+        self.ax[f_id].plot(*args)
+        plt.draw()
+        plt.pause(0.001)
+
+    def plotx(self, f_id, *args):
+        """Draws."""
+        if f_id not in self.ax:
+            return
+
+        self.ax[f_id].plot(*args)
+        plt.draw()
+        plt.pause(0.001)
+
+    def set_title(self, f_id, title):
+        """Set title to axes."""
+        if f_id not in self.ax:
+            return
+
+        self.ax[f_id].set_title(title)
+
+    def savefig(self, f_id, fname, **kwargs):
+        """Saves the figure."""
+        if f_id not in self.ax:
+            return
+
+        self.fig[f_id].savefig(fname, **kwargs)