petal-qc 0.0.0__py3-none-any.whl

petal_qc/thermal/contours.py

@@ -0,0 +1,378 @@
+"""Utilities for contours.
+
+A Contour is a a list of 2D points tha tdefine a curve or contour.
+This provides aset of utilities to operate on these lists.
+
+"""
+import random
+import sys
+
+import matplotlib.path as mplPath
+import numpy as np
+
+from petal_qc.utils.Geometry import Point
+
+
+def pldist(point, start, end):
+    """Return distance of point to line formed by start-end.
+
+    Args:
+    ----
+        point: The point
+        start: Starting point of line
+        end: End point of line
+
+    """
+    if np.all(np.equal(start, end)):
+        return np.linalg.norm(point - start)
+
+    return np.divide(np.abs(np.linalg.norm(np.cross(end - start, start - point))),
+                     np.linalg.norm(end - start))
+
+
+def closest_segment_point(P, A, B):
+    """Return distance to segment and closest point in segment.
+
+    Args:
+    ----
+        P: point
+        A: start of segment
+        B: end of segment
+
+    """
+    try:
+        M = B - A
+
+    except TypeError:
+        pass
+
+    t0 = np.dot(P-A, M)/np.dot(M, M)
+    C = A + t0*M
+    d = np.linalg.norm(P-C)
+
+    return d, C
+
+
+def find_closest(x0, y0, cont, return_index=False):
+    """Find point in contour closest to given point.
+
+    Args:
+    ----
+        x0: X of point
+        y0: Y of point
+        cont: The contour
+        return_index: if True returns the index in array
+
+    Return:
+    ------
+        min_point: the coordinates of closest point
+
+    """
+    npts = len(cont)
+    min_dist = sys.float_info.max
+    min_point = None
+    imin = -1
+    for ipt in range(npts):
+        x, y = cont[ipt, :]
+        dist = (x-x0)**2+(y-y0)**2
+        if dist < min_dist:
+            imin = ipt
+            min_dist = dist
+            min_point = (x, y)
+
+    if return_index:
+        return imin, min_point
+    else:
+        return min_point
+
+
+def generate_points_inside_contour(C, n, region=None):
+    """Generate n points that are inside the contour.
+
+    Args:
+    ----
+        C: the contour
+        n: number of points to generate
+        region: if given generate withing region (Xmin, Ymin, Xwidth, Ywidth)
+
+    Returns
+    -------
+        Array with points
+
+    """
+    out = np.zeros([n, 2])
+    if region:
+        min_x = region[0]
+        min_y = region[1]
+        max_x = min_x + region[2]
+        max_y = min_y + region[3]
+    else:
+        min_x, min_y, max_x, max_y = contour_bounds(C)
+
+    npts = 0
+    path = mplPath.Path(C)
+    while npts < n:
+        P = [random.uniform(min_x, max_x), random.uniform(min_y, max_y)]
+        if path.contains_point(P):
+            out[npts, :] = P
+            npts += 1
+
+    return out
+
+
+def find_closest_point(x0, y0, C):
+    """Find the closest point in contour."""
+    P = np.array([x0, y0])
+    indx, A = find_closest(x0, y0, C, return_index=True)
+
+    i1 = indx - 1
+    if indx == 0:
+        i1 -= 1
+
+    i2 = indx + 1
+    if indx == len(C)-1:
+        i2 = 2
+
+    d1, P1 = closest_segment_point(P, C[i1, :], A)
+    d2, P2 = closest_segment_point(P, A, C[i2, :])
+    if d1 <= d2:
+        return d1, P1
+
+    else:
+        return d2, P2
+
+
+def contour_simplify(C, epsilon, return_mask=False):
+    """Simplyfy the contour using RDP algorithm.
+
+    Args:
+    ----
+        C: the contour
+        epsilon: RDP alg epsilon
+        return_mask: if True, return the indices of selected points
+                     rather than the list of points.
+
+    """
+    stk = []
+
+    start_index = 0
+    last_index = len(C) - 1
+    stk.append([start_index, last_index])
+
+    global_start_index = start_index
+    indices = np.ones(last_index - start_index + 1, dtype=bool)
+
+    while stk:
+        start_index, last_index = stk.pop()
+
+        dmax = 0.0
+        index = start_index
+
+        for i in range(index + 1, last_index):
+            if indices[i - global_start_index]:
+                d = pldist(C[i], C[start_index], C[last_index])
+                if d > dmax:
+                    index = i
+                    dmax = d
+
+        if dmax > epsilon:
+            stk.append([start_index, index])
+            stk.append([index, last_index])
+        else:
+            for i in range(start_index + 1, last_index):
+                indices[i - global_start_index] = False
+
+    if return_mask:
+        return indices
+    else:
+        return C[indices]
+
+
+def contour_smooth(C, distance):
+    """Removes outliers that are at distance > distance from neighbours."""
+    npts = len(C)
+    for i in range(npts-2):
+        dst, P = closest_segment_point(C[i, :], C[i-1, :], C[i+1, :])
+        if dst > distance:
+            C[i] = P
+
+    return C
+
+
+def contour_length(C):
+    """Return the length of a contour."""
+    n = len(C)
+    dst = 0.0
+    for i in range(n-1):
+        dd = np.linalg.norm(C[i, :] - C[i+1, :])
+        dst += dd
+
+    return dst
+
+
+def contour_path_length(C, norm=False):
+    """Return the path length of a contour.
+
+    Args:
+    ----
+        C: the contour
+        norm: if true, the lenght wil be normalized to 1.
+
+    Returns
+    -------
+        An array with the length of the contour at each points.
+        0 for the first point total_length (or 1) for tha last.
+
+    """
+    npts = len(C)
+    D = np.zeros(npts)
+    dst = 0
+    X0 = 0
+    for i in range(npts):
+        X = C[i, :]
+        if i:
+            dst += np.linalg.norm(X-X0)
+
+        D[i] = dst
+        X0 = X
+
+    D = D/dst
+    return D
+
+
+def contour_area(C):
+    """Return the area of a contour."""
+    def Ia(i, j):
+        return (C[i, 0]-C[j, 0])*(C[i, 1]+C[j, 1])
+
+    n = len(C)
+    area = Ia(0, n-1)
+    for i in range(n-2):
+        area += Ia(i+1, i)
+
+    return 0.5*abs(area)
+
+
+def in_contour(x, y, C):
+    """Tell if it is inside the contour."""
+    path = mplPath.Path(C)
+    return path.contains_point(x, y, C)
+
+
+def get_average_in_contour(img, C):
+    """Gets average and std of points within contour.
+
+    We are assuming here that coordinates are integers, ie,
+    indices of the matrix of values.
+
+    Args:
+    ----
+        img: The image
+        C: The contour
+
+    Returns
+    -------
+        avg, std: averate and std.
+
+    """
+    values = []
+    path = mplPath.Path(C)
+    my, mx = img.shape
+    min_x, min_y, max_x, max_y = contour_bounds(C)
+    for ix in range(int(min_x), int(max_x+1)):
+        if ix < 0 or ix >= mx:
+            continue
+
+        for iy in range(int(min_y), int(max_y)+1):
+            if iy < 0 or iy >= my:
+                continue
+
+            if path.contains_point([ix, iy]):
+                values.append(img[iy, ix])
+
+    return np.mean(values), np.std(values)
+
+
+def contour_bounds(C):
+    """Compute the contour bounds.
+
+    Returns
+    -------
+        (min_x, min_y, max_x, maxy)
+
+    """
+    cmin = np.amin(C, axis=0)
+    cmax = np.amax(C, axis=0)
+    return cmin[0], cmin[1], cmax[0], cmax[1]
+
+
+def contour_CM(C):
+    """Return the contour center of mass."""
+    return np.mean(C, axis=0)
+
+
+def inset_contour(C, dist):
+    """Create an inset of the controur.
+
+    Args:
+    ----
+        C: Input contour
+        dist: distance inwards
+
+    Return:
+    ------
+        array: output contour
+
+    """
+    n = len(C)
+    out = np.zeros(C.shape)
+    M = Point(np.mean(C[:, 0]), np.mean([C[:, 1]]))
+    for i in range(n-1):
+        A = Point(C[i, :])
+        B = Point(C[i+1, :])
+        delta = (B - A).norm().cw()
+
+        O = A + dist*delta
+        out[i, 0] = O.x
+        out[i, 1] = O.y
+
+    out[-1, :] = out[0, :]
+    return out
+
+
+def adjust_contour(cont):
+    """Swap contour axis (x<->y) and flip Y."""
+    out = np.zeros(cont.shape)
+    out[:, 0] = cont[:, 1]
+    out[:, 1] = cont[:, 0]
+    return out
+
+
+def contour_eval(C, x):
+    """Interpolate contour Y value at X.
+
+    For this to work properly we need that the contour behaves somehow as a 1D
+    as a function (monotonic).
+
+    """
+    value = np.interp(x, C[:, 0], C[:, 1])
+    return value
+
+
+if __name__ == "__main__":
+    C = np.loadtxt("long_contour.csv")
+
+    CM0 = contour_CM(C)
+    d0, pt0 = find_closest_point(CM0[0], CM0[1], C)
+
+    Cs = contour_simplify(C, 1.)
+    CMs = contour_CM(Cs)
+    ds, pts = find_closest_point(CM0[0], CM0[1], Cs)
+    d = np.linalg.norm(pt0-pts)
+    print("no. of points {}".format(len(C)))
+    print("no. of points {}".format(len(Cs)))
+    print(d0)
+    print(ds)
+    print(pt0)
+    print(pts)
+    print("Distance:", d)

petal_qc/thermal/create_IRCore.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+"""Create IRCore object from file."""
+import json
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+
+import dateutil
+import matplotlib.pyplot as plt
+
+from petal_qc.thermal import IRBFile
+from petal_qc.thermal import IRCore
+from petal_qc.thermal import IRPetal
+from petal_qc.thermal import Petal_IR_Analysis
+from petal_qc.thermal import PipeFit
+from petal_qc.thermal.IRDataGetter import IRDataGetter
+from petal_qc.thermal.IRPetalParam import IRPetalParam
+from petal_qc.utils.utils import output_folder
+
+
+def get_db_date(timestamp=None):
+    """Convert a date string into the expected DB format.
+
+    Args:
+    ----
+        timestamp: A date in string format
+
+    """
+    def date2string(the_date):
+        out = the_date.isoformat(timespec='milliseconds')
+        if out[-1] not in ['zZ']:
+            out += 'Z'
+
+        return out
+        # return the_date.strftime("%Y-%m-%dT%H:%M:%S.000Z")
+
+    out = None
+    if timestamp is None:
+        out = date2string(datetime.now())
+    elif isinstance(timestamp, datetime):
+        out = date2string(timestamp)
+    else:
+        try:
+            this_date = dateutil.parser.parse(timestamp)
+            out = date2string(this_date)
+        except Exception:
+            out = ""
+
+    return out
+
+
+def create_IR_core(options):
+    """Entry point."""
+    # Obtain the Data getter.
+    try:
+        getter = IRDataGetter.factory(options.institute, options)
+
+    except NotImplemented:
+        print("*** Invalid institute name. ***")
+        return
+
+    # Set parameters from command line
+    params = IRPetal.IRPetalParam(options)
+    params.debug = False
+
+    # Open the sequence file
+    print("## ", options.files)
+    irbf = IRBFile.open_file(options.files)
+
+    # FInd first image below the threshold or the corresponding frame
+    # We will use the pipe obtained from here as the reference
+    # for the next
+    try:
+        print("Get the reference image.")
+        min_T, i_min, values = getter.find_reference_image(irbf, params.thrs, nframes=10)
+        print("Image size: {} x {}".format(values[0].shape[0], values[0].shape[1]))
+
+        if options.debug:
+            Petal_IR_Analysis.show_2D_image(values)
+
+    except LookupError as e:
+        print(e)
+        sys.exit()
+
+    # Get the pipes
+    print("Get the pipes.")
+    pipes = getter.extract_pipe_path(values, params)
+    npipes = len(pipes)
+    transforms = [None, None]
+    fitter = [None, None]
+    sensors = [None, None]
+
+    print("Fit pipes and find sensor positions.")
+    ordered_pipes = [None, None]
+    pipe_order = [0, 0]
+    for i in range(2):
+        pipe_type = PipeFit.PipeFit.guess_pipe_type(pipes[i])
+        pipe_order[i] = pipe_type
+        PF = PipeFit.PipeFit(pipe_type)
+        R = PF.fit_ex(pipes[i], factor=getter.factor)
+        if options.debug:
+            PF.plot()
+
+        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
+    deltaT = 0.0
+    if options.tco2 != 0:
+        deltaT = -35.0 - options.tco2
+
+    # get the framea from where extract the data
+    # reorder if needed
+    frames = getter.get_analysis_frame(irbf)
+    if pipe_order[0]:
+        tmp = frames[0]
+        frames[0] = frames[1]
+        frames[1] = tmp
+
+    values = getter.get_IR_data(frames, rotate=True)
+    results = getter.analyze_IR_image(values, pipes, sensors, 0, params)
+    if options.debug:
+        fig, ax = plt.subplots(2, 2, tight_layout=True)
+        ax[0][0].set_title("Side 0")
+        ax[0][1].set_title("Side 1")
+
+        for iside in range(2):
+            R = results[iside]
+            ax[0][iside].plot(R.path_length, R.path_temp)
+            ax[1][iside].plot([x for x in range(10)], R.sensor_avg)
+
+    core = IRCore.IRCore(options.SN, options.alias, results, params)
+    core.set_files(options.files)
+    core.date = get_db_date(frames[0].timestamp)
+    core.institute = params.institute
+    core.apply_deltaT(deltaT)
+
+    # Check if we are given an output folder
+    ofile = output_folder(options.folder, options.out)
+    with open(ofile, "w") as ofile:
+        core.to_json(ofile)
+
+    if options.debug:
+        plt.show()
+
+
+if __name__ == "__main__":
+    from argparse import ArgumentParser
+
+    # Argument parser
+    parser = ArgumentParser()
+    parser.add_argument('files', nargs='*', help="Input files")
+    parser.add_argument("--nframe", type=int, default=-1, help="Number of frames. (negative means all.")
+    parser.add_argument('--frame', type=int, default=-1, help="First frame to start.")
+    parser.add_argument("--tco2", default=0, type=float, help="CO2 inlet temperature.")
+    parser.add_argument("--out", default="core.json", help="Output file name")
+    parser.add_argument("--alias", default="", help="Alias")
+    parser.add_argument("--SN", default="", help="serial number")
+    parser.add_argument("--folder", default=None, help="Folder to store output files. Superseeds folder in --out")
+
+    IRPetalParam.add_parameters(parser)
+
+    options = parser.parse_args()
+    if len(options.files) == 0:
+        print("I need an input file")
+        sys.exit()
+
+    create_IR_core(options)