petal-qc 0.0.0__py3-none-any.whl

petal_qc/metrology/comparisonTable.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""Create a table from a set of PDB JSon files."""
+
+import sys
+import json
+import openpyxl as xl
+from openpyxl.worksheet.cell_range import CellRange
+from pathlib import Path
+
+
+def comparisonTable(files, options):
+    """Creqt3 the table."""
+    wb = xl.Workbook()
+    ws = wb.active
+
+    dir(ws)
+
+    firstC = ["All", "R0", "R1", "R2", "R3_0", "R3_1", "R4_0", "R4_1", "R5_0", "R5_1"]
+    for i, lbl in enumerate(firstC):
+        ws.cell(row=3+i, column=1).value = lbl
+
+    for i, ifile in enumerate(files):
+        P = Path(ifile).expanduser().resolve()
+        print(P.stem)
+        petal, side = P.stem.split('_')
+        with open(P, "r") as inp:
+            Js = json.load(inp)
+            if len(Js["results"]["METROLOGY_FRONT"]):
+                Js = Js["results"]["METROLOGY_FRONT"]
+            else:
+                Js = Js["results"]["METROLOGY_BACK"]
+
+        if i % 2 == 0:
+            ws.cell(row=1, column=i+2).value = petal
+
+        ws.cell(row=2, column=i+2).value = side
+        ws.cell(row=3, column=i+2).value = Js["FLATNESS_GLOBAL"]
+        ws.cell(row=3, column=i+2).number_format = '0.000'
+        for j, v in enumerate(Js["FLATNESS_LOCAL"]):
+            cell = ws.cell(row=4+j, column=i+2)
+            cell.value = v
+            cell.number_format = '0.000'
+
+    wb.save(options.out)
+
+
+if __name__ == "__main__":
+    from argparse import ArgumentParser
+    parser = ArgumentParser()
+    parser.add_argument('files', nargs='*', help="Input files")
+    parser.add_argument("--out", default="table.xlsx")
+
+    options = parser.parse_args()
+    if len(options.files) == 0:
+        print(sys.argv[0])
+        print("I need an input file")
+        sys.exit()
+
+    comparisonTable(options.files, options)

petal_qc/metrology/convert_mitutoyo.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+"""Convert mitutoyo output into CSV."""
+import argparse
+import fnmatch
+import io
+import os
+import re
+import sys
+from pathlib import Path
+
+
+def all_files(root, patterns='*', single_level=False, yield_folders=False):
+    """A generator that reruns all files in the given folder.
+
+    Args:
+    ----
+        root (file path): The folder
+        patterns (str, optional): The pattern of the files. Defaults to '*'.
+        single_level (bool, optional): If true, do not go into sub folders. Defaults to False.
+        yield_folders (bool, optional): If True, return folders as well. Defaults to False.
+
+    Yields
+    ------
+        str: file path name
+
+    """
+    patterns = patterns.split(';')
+    for path, subdirs, files in os.walk(root):
+        if yield_folders:
+            files.extend(subdirs)
+
+        files.sort()
+        for name in files:
+            for pattern in patterns:
+                if fnmatch.fnmatch(name, pattern):
+                    yield os.path.join(path, name)
+                    break
+
+        if single_level:
+            break
+
+
+def mitutoyo2cvs(infiles, ofile, label='\\w+', data_type="Punto", keep=False, fill=-1):
+    """Converts a Mityutoyo ASCII file to csv.
+
+    Stores the X, Y and Z coordinates in the objects defined by object with
+    label matching the input.
+
+    Args:
+    ----
+        infiles: List of input files
+        ofile: Output file
+        label (optional): label of the objects to convert. Defaults to '\w+'.
+        data_type (optional): Type of objects. Defaults to "Punto".
+        keep (optional): keep the label in the output table. Defaults to False.
+        fill (optional): if given, fill CVS lines to have up to fill items
+
+    """
+    # print("^{}:\\s+({})".format(type, label))
+    rgx = "^({}):\\s+({})".format(data_type, label)
+    start = re.compile(rgx, re.DOTALL)
+
+    is_file = False
+    if isinstance(ofile, io.IOBase):
+        fout = ofile
+    else:
+        try:
+            fout = open(ofile, 'w', encoding="utf-8")
+        except TypeError:
+            fout = ofile
+
+        is_file = True
+
+    if keep:
+        fout.write("X,Y,Z, label\n")
+    else:
+        fout.write("X,Y,Z\n")
+
+    for fnam in infiles:
+        ifile = Path(fnam).expanduser().resolve()
+        fin = open(ifile, 'r', encoding='ISO-8859-1')
+
+        for line in fin:
+            line = line.replace("C�rculo", "Círculo") \
+                       .replace("L�nea", "Linea") \
+                       .replace("�ngulo", "Ángulo") \
+                       .replace("Di�metro", "Diámetero")
+            r = start.match(line)
+            if r:
+                the_type = r.group(1)
+                the_label = r.group(2)
+
+            else:
+                continue
+
+            line_data = []
+            while True:
+                ss = fin.readline()
+                if len(ss)==0 or ss[0] == '\n':
+                    break
+
+                dd = [s.strip().replace(',', '.') for s in ss.split('=')]
+                try:
+                    line_data.append(float(dd[1]))
+                except IndexError:
+                    print("Incomplete data line.")
+                    print(ss)
+                    print(dd)
+
+            if fill > 0:
+                while len(line_data) < fill:
+                    line_data.append(0.0)
+
+            slin = ','.join([str(v) for v in line_data])
+            fout.write(slin)
+            if keep:
+                fout.write(",{}\n".format(the_label))
+            else:
+                fout.write('\n')
+
+        fin.close()
+
+    if is_file:
+        fout.close()
+
+
+def convert_all_in_folder(indir, outdir, patterns='*', label='\\w+', data_type="Punto"):
+    """Call mitutoyo2cvs to all files in folder and store them in outpuit folder.
+
+    Args:
+    ----
+        indir: input folder
+        outdir: output folder
+        patterns (optional): ';' separted list of file patterns to match. Defaults to '*'.
+        label (optional): see mitutoyo2cvs. Defaults to '\w+'.
+        data_type (optional): see mitutoyo2cvs. Defaults to "Punto".
+
+    """
+    idir = ifile = Path(indir).expanduser().resolve()
+    if not idir.exists():
+        raise ValueError("Input folder does not exist.")
+
+    odir = ifile = Path(outdir).expanduser().resolve()
+
+    for ipath in all_files(idir, patterns=patterns):
+        ifile = Path(ipath)
+        oname = ifile.stem + '.csv'
+        fdir = ifile.parent.relative_to(idir)
+        fdir = Path.joinpath(odir, fdir)
+        if not fdir.exists():
+
+            Path.mkdir(fdir, parents=True)
+
+        ofile = Path.joinpath(fdir, oname)
+        mitutoyo2cvs([ifile], ofile, label, data_type)
+        print(ifile)
+        print(ofile)
+        print('.')
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("mitutoyo_files", nargs='*',
+                        help="The Mitutoyo file to parse")
+    parser.add_argument("--label", default="\\w+", help="The label to select")
+    parser.add_argument("--type", default="Punto", help="The class to select")
+    parser.add_argument("--out", help="Outout CSV file", default="out.csv")
+    parser.add_argument("--keep_label", dest="keep", default=False, action="store_true", help="Store label in output")
+
+    args = parser.parse_args()
+    if len(args.mitutoyo_files) == 0:
+        print("I need an input file")
+        sys.exit()
+
+    mitutoyo2cvs(args.mitutoyo_files, args.out, args.label, args.type, args.keep)

petal_qc/metrology/convert_smartscope.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""Convert mitutoyo output into CSV."""
+import io
+import re
+import sys
+from pathlib import Path
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+from petal_qc.metrology import DataFile
+from .analyze_locking_points import analyze_locking_point_data
+
+def get_data_chunck(flist, data_type, ofile):
+    """Get one data type chunk from file
+
+    Args:
+        fname (): input file
+        data_tyle (): data type
+        ofile (): file object for output.
+
+    """
+    rgx = "Step Name:\\s+({}).*?=".format(data_type)
+    print("Regex: {}\n".format(rgx))
+    start = re.compile(rgx, re.DOTALL)
+        
+    for fname in flist:
+        ifile = Path(fname).expanduser().resolve()
+        print(ifile)
+        ss = None
+        with  open(ifile, 'r', encoding='ISO-8859-1') as fin:
+            ss = fin.read()
+
+        if not ss:
+            return
+                
+        for txt in start.finditer(ss):
+            print(txt.group(1))
+            if ofile:
+                ofile.write(txt.group(0)+'\n')
+    
+
+def read_smartscope(fnam, ofile, data_type, keep=False,):
+    """Convert a SmartScope txt file into CVS
+
+    Args:
+        fnam: Input file pat
+        ofile: Output file
+        data_type: Data label in file
+        keep (optional): keep the label in the output table. Defaults to False.
+
+    """
+    ifile = Path(fnam).expanduser().resolve()
+    fin = open(ifile, 'r', encoding='ISO-8859-1')
+
+    is_file = False
+    if isinstance(ofile, io.IOBase):
+        fout = ofile
+    else:
+        fout = open(ofile, 'w')
+        is_file = True
+
+    if keep:
+        fout.write("X,Y,Z, label\n")
+    else:
+        fout.write("X,Y,Z\n")
+
+    rgx = "^Step Name:\\s+{}".format(data_type)
+    start = re.compile(rgx, re.DOTALL)
+    finder = re.compile("^Finder Name")
+
+    while True:
+        line = fin.readline()
+        if not line:
+            break
+
+        r = start.match(line)
+        if not r:
+            continue
+
+        eof = False
+        while True:
+            line = fin.readline()
+            if not line:
+                eof = True
+                break
+
+            r = finder.match(line)
+            if r:
+                break
+
+        # Read the header line and to the numbers
+        while not eof:
+            line = fin.readline()
+            if not line:
+                break
+
+            if line[0] == '-':
+                continue
+
+            if line[0] == "=":
+                break
+
+            items = line.split()
+            values = [ float(x) for x in items[2:5]]
+            fout.write("{:6f}, {:6f}, {:6f}\n".format(values[1], values[0], values[2]))
+
+    fout.close()
+
+def do_locking_points(args):
+    ifile = args.smartscope_files[0]
+    flatness_data = DataFile.read(ifile, "PetalPlane")
+    locator_data = DataFile.read(ifile, ".*_FineFlatness")
+
+    data = np.concatenate((flatness_data, locator_data))
+    analyze_locking_point_data(data, document=None, nbins=50, plane_fit=True)
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("smartscope_files", nargs='*',
+                        help="The SmartScope files to parse")
+    parser.add_argument("--label", default="\\w+", help="The label to select")
+    parser.add_argument("--out", help="Output CSV file", default="out.csv")
+    parser.add_argument("--keep_label", dest="keep", default=False, action="store_true", help="Store label in output")
+
+    args = parser.parse_args()
+    if len(args.smartscope_files) == 0:
+        print("I need an input file")
+        sys.exit()
+
+
+
+    # do_locking_points(args)
+    
+    fout = open(Path(args.out).expanduser().resolve(), 'w')
+    get_data_chunck(args.smartscope_files, args.label, fout)
+    fout.close()
+    
+    
+    #read_smartscope(args.smartscope_files[0], args.out, args.label, args.keep)
+
+    plt.show()