petal-qc 0.0.0__py3-none-any.whl

petal_qc/thermal/pipe_read.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""Read the real pipe and create the pipe contour to compare with.
+
+It reads PNG files produced from the petal 3D CAD model and extracts the pipe
+path and the sensor areas. It stores all this information in files that are
+later read by PipeFit.
+
+To create the files one needs to run the script twice, one for the front side
+(--front) and anther for the back side (--back).
+
+"""
+import random
+import sys
+from argparse import ArgumentParser
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+import skimage
+
+from petal_qc.thermal.contours import adjust_contour
+from petal_qc.thermal.contours import contour_simplify
+from petal_qc.thermal.contours import find_closest
+
+script_path = Path(__file__).absolute().parent
+
+
+def crange(start, end, modulo):
+    """Circular range.
+
+    Args:
+    ----
+        start: Start
+        end: End
+        modulo: Max value
+
+    Yields
+    ------
+        int: the following value
+
+    """
+    if start > end:
+        while start < modulo:
+            yield start
+            start += 1
+        start = 0
+
+    while start < end:
+        yield start
+        start += 1
+
+
+def get_pipe_path(im, P1_i, P2_i, debug=False):
+    """Find pipe path and save to file.
+
+    Given the inlet and outlet point, creates the path of the pipe.
+
+    Args:
+    ----
+        im: THe image with the pipe
+        P1_i: Starting point
+        P2_i: End point
+        debug: show stuff
+
+    """
+    contours = skimage.measure.find_contours(im)
+    pipe = adjust_contour(np.array(contours[0]))
+
+    npts = len(pipe)
+    i1, P1 = find_closest(P1_i[0], P1_i[1], pipe, True)
+    i2, P2 = find_closest(P2_i[0], P2_i[1], pipe, True)
+
+    indx = list(crange(i1, i2, npts))
+    inner = pipe[indx, :]
+    linner = len(inner)
+
+    indx = list(crange(i2, i1, npts))
+    outer = np.flipud(pipe[indx, :])
+    louter = len(outer)
+
+    if linner > louter:
+        indx = random.sample(range(0, linner), linner - louter)
+        inner = np.delete(inner, indx, 0)
+    else:
+        indx = random.sample(range(0, louter), louter - linner)
+        outer = np.delete(outer, indx, 0)
+
+    center = (inner + outer)/2.0
+
+    small_center = contour_simplify(center - P1, 0.5)
+    print("original len {}, small len {}".format(len(center), len(small_center)))
+
+    if debug:
+        fig, ax = plt.subplots(1, 2, tight_layout=True)
+        ax[0].plot(inner[:, 0], inner[:, 1])
+        ax[0].plot(outer[:, 0], outer[:, 1])
+        ax[0].plot(center[:, 0], center[:, 1])
+        ax[1].plot(center[:, 0], center[:, 1])
+        ax[1].plot(small_center[:, 0], small_center[:, 1])
+
+    return small_center, P1
+
+
+def get_sensor_area(ims, P1, debug=False):
+    """Find sensor area."""
+    if debug:
+        fig, ax = plt.subplots(1, 1, tight_layout=True)
+
+    contours = skimage.measure.find_contours(ims)
+
+    ncontours = len(contours)
+    sensors = []
+    for i in range(ncontours):
+        sensor = adjust_contour(contours[i]) - P1
+        sensor = contour_simplify(sensor, 1)
+        sensors.append(sensor)
+        if debug:
+            ax.plot(sensor[:, 0], sensor[:, 1])
+
+    return sensors
+
+
+def main(opts):
+    """Main entry."""
+    global script_path
+    front = opts.front
+    if opts.folder:
+        folder = Path(opts.folder).expanduser().absolute()
+        if folder.exists():
+            script_path = folder
+        else:
+            print("Folder {} does not exist.".format(opts.folder))
+            sys.exit()
+
+    if front:
+        in_file = "pipe-front.png"
+        in_sensors = "pipe-front-sensors-only.png"
+        out_file = "pipe_front.npz"
+        P1_i = [608, 817]      # [602.9, 779.5]   # [568.915, 768.52]
+        P2_i = [593.5, 818.7]  # [588.7, 781.0]  # [582.9, 766.7]
+
+    else:
+        in_file = "pipe-back.png"
+        in_sensors = "pipe-back-sensors-only.png"
+        out_file = "pipe_back.npz"
+        P1_i = [251.8, 817.9]  # [256.0, 779.0]
+        P2_i = [266.1, 818.3]  # [270.5, 781.2]
+
+    # Get the pipe
+    im = skimage.io.imread(script_path.joinpath(in_file), as_gray=True)
+    im = np.flipud(im)
+
+    pipe, P1 = get_pipe_path(im, P1_i, P2_i, debug=opts.debug)
+
+    # Now gethte sensors
+    ims = skimage.io.imread(script_path.joinpath(in_sensors), as_gray=True)
+    ims = np.flipud(ims)
+
+    sensors = get_sensor_area(ims, P1, debug=opts.debug)
+
+    # Save stuff
+    np.savez_compressed(out_file, pipe=pipe, *sensors)
+
+    fig, ax = plt.subplots(1, 1, tight_layout=True)
+    ax.plot(pipe[:, 0], pipe[:, 1])
+
+    for S in sensors:
+        ax.plot(S[:, 0], S[:, 1])
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    parser = ArgumentParser(description="PipeContour")
+    parser.add_argument("--folder", default=None, help="Folder to find the pictures.")
+    parser.add_argument("--front", action="store_true", dest='front', default=True, help="Front side")
+    parser.add_argument("--back", action="store_false", dest='front', help="Back side")
+    parser.add_argument("--debug", action="store_true", default=False, help="Debug.")
+
+    opts = parser.parse_args()
+
+    main(opts)

petal_qc/thermal/show_IR_petal.py

@@ -0,0 +1,420 @@
+#!/usr/bin/env python3
+"""Do the thermal analysis of the petal core."""
+import os
+import subprocess
+import sys
+import tempfile
+from argparse import Action
+from argparse import ArgumentParser
+from pathlib import Path
+from pathlib import PurePath
+
+import matplotlib.pyplot as plt
+import matplotlib.ticker as ticker
+import numpy as np
+from petal_qc.thermal import contours
+from petal_qc.thermal import IRBFile
+from petal_qc.thermal import IRPetal
+from petal_qc.thermal import PipeFit
+from petal_qc.thermal.Petal_IR_Analysis import AnalysisResult
+from petal_qc.thermal.Petal_IR_Analysis import show_2D_image
+from petal_qc.thermal.PetalColorMaps import HighContrast
+
+import petal_qc.utils.Progress as Progress
+import petal_qc.utils.utils as utils
+
+
+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."""
+        setattr(namespace, self.dest, list(map(int, values.split(','))))
+
+
+def get_min_max(values, step=1.0):
+    """Return min and max.
+
+    The values are alined with step.
+
+    Args:
+    ----
+        values: Array of values
+        step (optional): The step_. Defaults to 1.0.
+
+    Returns
+    -------
+        min, max.
+
+    """
+    vmax = np.amax(values)
+    vmin = np.amin(values)
+    ivmax = round(vmax)
+    if ivmax < vmax:
+        ivmax += step
+        if abs(ivmax-vmax) < 0.25*step:
+            ivmax += step
+
+    ivmin = np.round(vmin)
+    if ivmin > vmin:
+        ivmin -= step
+        if abs(ivmin-vmin) < 0.25*step:
+            ivmin -= step
+
+    return ivmin, ivmax
+
+
+def find_ffmpeg():
+    """Returns the path of ffmpeg."""
+    folders = os.environ['PATH'].split(':')
+
+    ffmpeg = None
+    for p in folders:
+        exe = Path(PurePath(p, "ffmpeg"))
+        if exe.exists():
+            ffmpeg = exe
+            break
+
+    if not ffmpeg:
+        raise Exception("Could not find ffmpeg")
+
+    return ffmpeg
+
+
+def create_movie(template, fout):
+    """Creates a movie frm a set of files.
+
+    The name of the files should be passed as a template, ej.,
+
+    <dir_name>/fig%3d.png
+
+    """
+    pout = utils.find_out_file_name(fout)
+    ffmpeg = find_ffmpeg()
+
+    try:
+        out = subprocess.run([ffmpeg, '-r', "10", '-i', template, '-c:v', "libx264", pout],
+                             capture_output=True,
+                             text=True,
+                             timeout=1,
+                             shell=False)
+        print(out)
+        print("Movie is ready.")
+
+    except subprocess.CalledProcessError as xx:
+        print("Error")
+        print("create_movie: error rc=%d.\n%s" % (xx.returncode, xx.output))
+
+    except Exception as xx:
+        print("Error")
+        print("create_movie: error rc=%d.\n%s" % (xx.returncode, xx.output))
+
+
+def show_cycle(irbf):
+    """Show thermal cycle.
+
+    Args:
+    ----
+        irbf: IRB file with sequence.
+
+    """
+    # Thermal cycle
+    T = []
+    D = []
+    prg = Progress.ShowProgress(irbf.n_images(), width=20)
+    prg.start()
+    for i, img in enumerate(irbf.images()):
+        prg.increase(1, True)
+        T.append(np.min(img.image))
+        D.append(img.timestamp)
+
+    prg.stop
+    fig, ax = plt.subplots(1, 1)
+    ax.plot(D, T, 'o-')
+
+
+def save_frame_data(the_frame, path_length, path_temp, sensor_avg, sensor_std):
+    """Save the frame data.
+
+    The input data are 2D arrays.
+        i=0 corresponds to the left image
+        i=1 corresponds to the right image
+
+    Args:
+    ----
+        the_frame: frams index in IRBFile
+        path_length: array with positions along the pipe
+        path_temp: array with temperatures in path_length positions
+        sensor_avg: Average T in sensor areas.
+        sensor_std: Temperature std in sensor area.
+
+    """
+    onam = "pipe_temp_{}.csv".format(the_frame)
+    ofile = open(onam, 'w')
+    ofile.write("x, T, x, T\n")
+    ll = [len(path_length[0]), len(path_length[1])]
+    nitems = max(ll[0], ll[1])
+    for i in range(nitems):
+        for j in range(2):
+            if i < ll[j]:
+                ofile.write("{:.4f}, {:.4f},".format(path_length[j][i], path_temp[j][i]))
+            else:
+                ofile.write(",,")
+
+        ofile.write('\n')
+    ofile.close()
+
+    onam = "sensor_temp_{}.csv".format(the_frame)
+    ofile = open(onam, 'w')
+    ofile.write("T, std, T, std\n")
+    ll = [len(sensor_avg[0]), len(sensor_avg[1])]
+    nitems = max(ll[0], ll[1])
+    for i in range(nitems):
+        for j in range(2):
+            if i < ll[j]:
+                ofile.write("{:.4f}, {:.4f},".format(sensor_avg[j][i], sensor_std[j][i]))
+            else:
+                ofile.write(",,")
+
+        ofile.write('\n')
+    ofile.close()
+
+
+def analyze_petal(ifileS, options):
+    """Main entry."""
+    from IRDataGetter import IRDataGetter
+    # Obtain the Data getter.
+    try:
+        getter = IRDataGetter.factory(options.institute, options)
+
+    except NotImplemented:
+        print("*** Invalid institute name. ***")
+        return
+    
+    # Load parameters from IRPetalParam
+    params = IRPetal.IRPetalParam(options)
+    params.debug = False
+
+    # Check if we are going to save the images
+    tmp_dir = None
+    if options.save_fig:
+        tmp_dir = tempfile.TemporaryDirectory()
+
+    # Open the sequence file
+    irbf = IRBFile.open_file(ifileS)
+
+    # Find first image below the threshold
+    # we will use the pipe obtained from here as the reference
+    # for the next
+    try:
+        min_T, i_min, values = getter.find_reference_image(irbf, params.thrs, nframes=2)
+        print("Image size: {} x {}".format(values[0].shape[0], values[0].shape[1]))
+
+        if options.debug:
+            show_2D_image(values)
+
+    except LookupError as e:
+        print(e)
+        sys.exit()
+
+    # Get the pipes
+    print("Extract pipes.")
+    pipes = getter.extract_pipe_path(values, params)
+    npipes = len(pipes)
+
+    # plot pipe paths on top of image
+    imgs = IRPetal.get_last_images()
+    nimgs = len(imgs)
+    if options.debug:
+        fig, ax = plt.subplots(1, nimgs, tight_layout=True)
+        if nimgs == 1:
+            ax = [ax, ]
+
+        for i, img in enumerate(imgs):
+            ax[i].imshow(imgs[i], origin="lower", cmap="jet")
+            ax[i].plot(pipes[i][:, 0], pipes[i][:, 1], linewidth=3, color="black")
+
+    # We now need to fit to the reference pipes to get the proper distance along
+    # the pipe.
+    transforms = [None, None]
+    fitter = [None, None]
+    sensors = [None, None]
+    ordered_pipes = [None, None]
+
+    print("Fit pipes and find sensor positions.")
+    for i in range(npipes):
+        # Fit the points to the "pipes"
+        pipe_type = PipeFit.PipeFit.guess_pipe_type(pipes[i])
+
+        PF = PipeFit.PipeFit(pipe_type)
+        R = PF.fit_ex(pipes[i])
+
+        transforms[pipe_type] = R
+        fitter[pipe_type] = PF
+
+        # Reorder points in pipe contour so that first point corresponds to
+        # the U-shape pipe minimum.
+        pipes[i] = IRPetal.reorder_pipe_points(pipes[i], pipe_type, R)
+        if ordered_pipes[pipe_type] is not None:
+            print("### Expect probles. 2 pipes of sme type")
+
+        ordered_pipes[pipe_type] = pipes[i]
+
+        # Now make the inverse transform of the area of sernsors and EoS
+        S = []
+        for s in PF.sensors:
+            o = PF.transform_inv(s, R)
+            S.append(o)
+        sensors[pipe_type] = S
+
+    pipes = ordered_pipes
+    if pipes[0] is None and pipes[1] is not None:
+        pipes[0] = pipes[1]
+        pipes[1] = None
+
+        sensors[0] = sensors[1]
+        sensors[1] = None
+
+        fitter[0] = fitter[1]
+        fitter[1] = None
+
+        transforms[0] = transforms[1]
+        transforms[1] = None
+
+    if options.debug:
+        fig, ax = plt.subplots(1, npipes, tight_layout=True)
+        if npipes == 1:
+            if fitter[0]:
+                ax = [ax, ]
+            else:
+                ax = [None, ax]
+
+        fig.suptitle("Fit result")
+        for i, F in enumerate(fitter):
+            if F is None:
+                continue
+
+            ax[i].plot(F.pipe[:, 0], F.pipe[:, 1])
+
+            out = F.transform_data(F.data, transforms[i])
+            ax[i].plot(out[:, 0], out[:, 1], 'o')
+
+    # Now go again through all the sequence and get the temperature along the pipes.
+    panels = [['P1', 'P2', 'T1', 'S1', 'SP1'],
+              ['P1', 'P2', 'T2', 'S2', 'SP2']]
+    labels = ["left", "right"]
+    tick_labels = ["R0", "R1", "R2", "R3", "R3", "R4", "R4", "R5", "R5", "EoS"]
+    fig, ax = plt.subplot_mosaic(panels,
+                                 tight_layout=True,
+                                 figsize=(10, 5),
+                                 gridspec_kw={'width_ratios': (0.25, 0.25, 0.17, 0.16, 0.17)})
+
+    print("Let's go")
+    for j, img in enumerate(irbf.images(options.first_frame, nframes=options.nframe)):
+        the_frame = options.first_frame + j
+        tmin = np.min(img[0].image)
+
+        sss = "Image {} - T {:.2f}".format(the_frame, tmin)
+        fig.suptitle(sss)
+        print(sss)
+        values = getter.get_IR_data(img, rotate=True)
+        results = getter.analyze_IR_image(values, pipes, sensors, 0, params)
+
+        # TODO: re-implement this with AnalysisResults
+        # if the_frame in options.frames:
+        #    save_frame_data(the_frame, path_length, path_temp, sensor_avg, sensor_std)
+
+        ii = 0
+        for i in range(2):
+            try:
+                if results[i] is None:
+                    continue
+            except IndexError:
+                continue
+
+            pmn, pmx = get_min_max(results[i].path_temp)
+            spmn, spmx = get_min_max(results[i].path_spread)
+            smn, smx = get_min_max(results[i].sensor_avg)
+
+            pan = "P{}".format(i+1)
+            cpan = "T{}".format(i+1)
+            span = "S{}".format(i+1)
+            sspan = "SP{}".format(i+1)
+            ax[pan].clear()
+            ax[pan].set_title("Image {}".format(labels[i]))
+            ax[pan].imshow(imgs[ii], origin='lower', cmap=HighContrast.reversed())   # , cmap='jet')
+            ax[pan].plot(pipes[ii][:, 0], pipes[ii][:, 1], linewidth=2, color="#000000")
+            for s in sensors[ii]:
+                ax[pan].plot(s[:, 0], s[:, 1], linewidth=2, color="#000000")
+
+            ax[cpan].clear()
+            ax[cpan].yaxis.set_major_locator(ticker.MultipleLocator(1))
+            ax[cpan].set_ylim(pmn, pmx)
+            ax[cpan].set_title("Pipe {}".format(labels[i]))
+            ax[cpan].plot(results[i].path_length, results[i].path_temp)
+
+            ax[sspan].clear()
+            ax[sspan].yaxis.set_major_locator(ticker.MultipleLocator(1))
+            ax[sspan].set_ylim(spmn, spmx)
+            ax[sspan].set_title("Spread {}".format(labels[i]))
+            ax[sspan].plot(results[i].path_length, results[i].path_spread)
+
+            ax[span].clear()
+            ax[span].yaxis.set_major_locator(ticker.MultipleLocator(1))
+            ax[span].set_ylim(smn, smx)
+            ax[span].set_xticks(range(10), labels=tick_labels)
+
+            ax[span].set_title("Sensors {}".format(labels[i]))
+            ax[span].plot(results[i].sensor_avg, 'o-')
+
+            ii += 1
+
+        plt.draw()
+        plt.pause(0.0001)
+        if the_frame in options.frames:
+            ofile = "frame_{:03d}.png".format(the_frame)
+            fig.savefig(ofile)
+
+        if tmp_dir:
+            ofile = "{}/fig{:03d}.png".format(tmp_dir.name, j)
+            fig.savefig(ofile)
+
+    if tmp_dir:
+        print("Creating movie")
+        template = "{}/fig%03d.png".format(tmp_dir.name)
+        print("template {}".format(template))
+        create_movie(template, options.save_fig)
+
+    print("Min temperature is {} @ {}".format(min_T, i_min))
+    for P in pipes:
+        if P is not None:
+            print("Pipe shape: {}".format(P.shape))
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    # This class contains the parameters needed for tha analysis.
+    from IRPetalParam import IRPetalParam
+
+    parser = ArgumentParser()
+    parser.add_argument('files', nargs='*', help="Input files")
+    parser.add_argument("--save_frames", dest="frames", default=[],
+                        action=CommaSeparatedListAction,
+                        help="Frames to save")
+    parser.add_argument("--nframe", type=int, default=-1, help="Number of frames. (negative means all.")
+    parser.add_argument('--first_frame', type=int, default=0, help="First frame to start.")
+    parser.add_argument("--orig", action="store_true", default=False, help="plot the original image")
+    parser.add_argument("--save_fig", default=None, help="Save all figures to make a film. Provide output file name")
+    parser.add_argument("--show_cycle", action="store_true", default=False, help="Show the thermal cycle.")
+
+    # Add default parameters to the parser
+    IRPetalParam.add_parameters(parser)
+
+    options = parser.parse_args()
+    nfiles = len(options.files)
+    if nfiles == 0:
+        print("I need an input file")
+        sys.exit()
+
+    analyze_petal(options.files, options)