Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0613· OpenAIAi2 WildChat-4.8M (AI2)

elif Secondstep == 2: Namefolderforframe = str(input('Введите путь до папки с…

  1. User

    elif Second_step == 2:

    Name_folder_for_frame = str(input('Введите путь до папки с кадрами:')) Start = int(input('Введите с какого кадра начинать:')) Step = int(input('Введите шаг, через который загружать фотографии:'))

    a = str(input('Введите размер окна (x1, x2, y1, y2):')) x1 = int(a.split(" ")[0]) x2 = int(a.split(" ")[1]) y1 = int(a.split(" ")[2]) y2 = int(a.split(" ")[3])

    find_speed(Name_folder_for_frame, x1, x2, y1, y2, Start, Step) matr = show("exp1_001.txt")

    m = 0 while m == 0: cycle = int(input("Введите количество циклов для RMS")) win = int(input("Введите размер окна для RMS"))

    a = RMS_cycle(matr, cycle, win)
    
    plt.imshow(a, cmap = 'Greys')
    plt.colorbar()
    plt.show()
    
    m = float(input('Введите 0, если вас не устроило RMS. Введите любое другое число, если устроило:'))
    

    def find_speed(Name_folder_for_frame, x1, x2, y1, y2, Start, Step):

    file = 'exp1_001.txt' location = 'C:/Users/1/'

    path = os.path.join(location, file)

    os.remove(path)

    frame_number_1 = Start frame_number_2 = frame_number_1 + Step

    old_frame_a = tools.imread(Name_folder_for_frame+'frame%d.jpg'% frame_number_1 ) old_frame_b = tools.imread(Name_folder_for_frame+'frame%d.jpg'% frame_number_2 )

    width = old_frame_a.shape[0] height = old_frame_a.shape[1]

    left_bound = x1 right_bound = x2 bot_bound = y1 top_bound = y2

    H = int(top_bound - bot_bound) L = int(right_bound - left_bound)

    frame_a = np.zeros((L, H)) frame_b = np.zeros((L, H))

    for ii in range(L): for jj in range(H): frame_a[ii][jj] = old_frame_a[left_bound + ii][bot_bound + jj] frame_b[ii][jj] = old_frame_b[left_bound + ii][bot_bound + jj]

    winsize = 32 # pixels, interrogation window size in frame A searchsize = winsize + 2 # pixels, search in image B overlap = winsize - 10 # pixels, 50% overlap dt = 0.01*(frame_number_2 - frame_number_1) # sec, time interval between pulses

    u0, v0, sig2noise = pyprocess.extended_search_area_piv(frame_a.astype(np.int32), frame_b.astype(np.int32), window_size=winsize, overlap=overlap, dt=dt, search_area_size=searchsize, sig2noise_method='peak2peak')

    x, y = pyprocess.get_coordinates( image_size=frame_a.shape, search_area_size=searchsize, overlap=overlap )

    flags = validation.sig2noise_val( sig2noise, threshold = 1.05)

    #plt.hist(sig2noise.flatten())

    u2, v2 = filters.replace_outliers( u0, v0, flags, method='localmean', max_iter=3, kernel_size=3)

    x, y, u3, v3 = scaling.uniform(x, y, u2, v2, scaling_factor = 200 ) # 96.52 microns/pixel

    x, y, u3, v3 = tools.transform_coordinates(x, y, u3, v3)

    tools.save('exp1_001.txt', x, y, u3, v3, flags)

    length = v3[0].size v3_bin = np.zeros(length) ВЫРЕЗКА СНИЗУ return def show(Name): list_x, list_y, list_u, list_v = [], [], [], [] with open(Name, "r") as file: lines = file.readlines()

    for x in lines[1:]: list_x.append(float(x.split( )[0]))

    for x in lines[1:]: list_y.append(float(x.split( )[1]))

    for x in lines[1:]: list_u.append(float(x.split( )[2]))

    for x in lines[1:]: list_v.append(float(x.split( )[3]))

    tolerance = -0.1 f = open(Name, "r") lines = f.readlines() f.close()

    binary_list = []

    for i in range(len(list_v)): if list_v[i] > tolerance: binary_list.append(0) elif list_v[i] <= tolerance and list_v[i] <0: binary_list.append(1)

    matrix = np.zeros((len(list_x), len(list_y)))

    fig, ax = plt.subplots(figsize=(10, 10))

    for i in range(len(binary_list)):

    if binary_list[i] != 0:
        ax.plot(list_x[i], list_y[i], '.k')
    
    elif binary_list[i] == 0:
        list_x[i] = 0
        list_y[i] = 0
    

    plt.axis('off') ax.set_aspect('equal') plt.savefig('plot.png', format='png')

    image = img.imread('plot.png') pic = np.zeros((image.shape[0],image.shape[1] )) for i in range (image.shape[0]): for j in range(image.shape[1]): pic[i,j] = (image[i,j,0]+ image[i,j,1] + image[i,j,2])/3

    for i in range(pic.shape[0]): for j in range(pic.shape[1]): if pic[i][j] == 1: pic[i][j] = 0 elif pic[i][j] == 0: pic[i][j] = 1

    image_shape = pic.shape

    for i in range(image_shape[0]): for j in range(image_shape[1]): pic[i, j] = (image[i, j, 0] + image[i, j, 1] + image[i, j, 2]) / 3

    for i in range(pic.shape[0]): for j in range(pic.shape[1]): if pic[i][j] == 1: pic[i][j] = 0 elif pic[i][j] == 0: pic[i][j] = 1

    start_x = 0 end_x = 0 for j in range(pic.shape[1]): if np.any(pic[:, j] == 1): start_x = j break for j in range(pic.shape[1] - 1, -1, -1): if np.any(pic[:, j] == 1): end_x = j + 1 break

    matrix_clean = np.zeros((pic.shape[0], end_x - start_x)) matrix_clean[:, :] = pic[:, start_x:end_x]

    pic = matrix_clean matrix = np.zeros((pic.shape)) z = 0 for i in range(pic.shape[0]): a = sum(pic[i,:]) if a>0: matrix[z, :] = pic[i,:] z+=1

    matrix_clean = np.zeros((z, matrix.shape[1])) matrix_clean[:,:] += matrix[:z,:]
    #print(matrix_clean.shape)

    return matrix_clean функция для расчета длины в одном срезе def Len(data): a = 0 #количество дискретов b = [] # отрезки for j in range(data.shape[0]-1): if data[j] == data[j+1] and data[j] == 1: a += 1 elif data[j] != data[j+1]: if a > 10: b.append(a) a = 0 if len(b) > 0: c = sum(b)/len(b) elif len(b) == 0: c = 0

    return c Среднее значение ширины полос нескольких срезов def Len_array(data): a = [] for i in range(data.shape[0]): b = Len(data[i,:]) if b > 0: a.append(b) if len(a) > 0: c = sum(a)/len(a) elif len(a) == 0: c = 0 return c

    Average_length = [] Name_folder_for_frame = str(input('Введите путь до папки с кадрами:')) Start = int(input('Введите с какого кадра начинать:')) Finish = int(input('Введите на каком кадре закончить:')) Step = int(input('Введите шаг, через который загружать фотографии:'))

    a = str(input('Введите размер окна (x1, x2, y1, y2):'))

    cycle = int(input("Введите количество циклов для RMS")) win = int(input("Введите размер окна для RMS"))

    x1 = int(a.split(" ")[0]) x2 = int(a.split(" ")[1]) y1 = int(a.split(" ")[2]) y2 = int(a.split(" ")[3])

    a = np.arange(Start, Finish, Step)

    list = []

    for g in tqdm(range(len(a))):

    find_speed(Name_folder_for_frame, x1, x2, y1, y2, Start, 1) matr = show("exp1_001.txt")

    a = RMS_cycle(matr, cycle, win)

    sum_ = Len_array(a)

    list.append(sum_)

    Start = Start + Step plt.plot(list)

    Код некорректно считает расстояние между линиями. Исправь код

  2. Assistant

    Код можно исправить следующим образом:

    1. В функции "Len_array" изменить условие в цикле на data[i, j] == 1, чтобы учитывать только значения, равные 1:
    for i in range(data.shape[0]):
        b = []
        for j in range(data.shape[1]):
            if data[i, j] == 1:
                a += 1
            elif data[i, j] != 1:
                if a > 10:
                    b.append(a)
                a = 0
        if len(b) > 0:
            c = sum(b) / len(b)
        else:
            c = 0
        if c > 0:
            a.append(c)
    
    1. В основной части кода, в цикле "for g in tqdm(range(len(a))):", изменить вызов функции "RMS_cycle" на "show":
    for g in tqdm(range(len(a))):
        find_speed(Name_folder_for_frame, x1, x2, y1, y2, Start, 1)
        matr = show("exp1_001.txt")
    
        sum_ = Len_array(matr)
    
        list.append(sum_)
    
        Start = Start + Step
        plt.plot(list)
    

    Таким образом, код будет корректно считать расстояние между линиями на каждом срезе и выводить его в виде графика.

  3. User

    Этот код учитывает то, что массив состоит только из 0 и 1?

  4. Assistant

    В предложенном коде не были учтены условия, когда массив состоит только из 0 и 1.

    Для учета такого условия в функции Len_array можно внести изменения следующим образом:

    def Len_array(data):
        a = []
        for i in range(data.shape[0]):
            b = []
            count = 0
            for j in range(data.shape[1]):
                if data[i, j] == 1:
                    count += 1
                elif data[i, j] != 1:
                    if count > 10:
                        b.append(count)
                    count = 0
            if len(b) > 0:
                c = sum(b) / len(b)
            else:
                c = 0
            a.append(c)
        if len(a) > 0:
            return sum(a) / len(a)
        else:
            return 0
    

    В данном случае добавлена переменная count, которая увеличивается только при встрече значения, равного 1, и обнуляется, когда встречается значение, отличное от 1. Затем, если значение count больше 10, оно добавляется в список b. Далее, вычисляется среднее значение этого списка b и добавляется в список a. Наконец, возвращается среднее значение списка a.

    Теперь функция Len_array будет корректно обрабатывать массивы состоящие только из 0 и 1, и возвращать среднюю ширину полос между линиями.

  5. User

    Этот код считает длину нулей или единиц?

  6. Assistant

    Данный код считает среднюю длину полос между линиями, которые равны 1. То есть, код считает среднюю длину отрезков, в которых элементы массива равны 1.

    В функции Len_array, переменная count увеличивается только в случае, если элемент массива равен 1, и обнуляется при встрече элемента, отличного от 1. Затем, если значение count больше 10, оно добавляется в список b. Наконец, вычисляется среднее значение списка b, которое представляет среднюю длину полос между линиями, равными 1.

    Если вам необходимо вычислить среднюю длину полос, состоящих из нулей, вы можете изменить условие в функции Len_array следующим образом:

    def Len_array(data):
        a = []
        for i in range(data.shape[0]):
            b = []
            count = 0
            for j in range(data.shape[1]):
                if data[i, j] == 0:  # изменено условие на равенство нулю
                    count += 1
                elif data[i, j] != 0:  # изменено условие на отличие не от нуля
                    if count > 10:
                        b.append(count)
                    count = 0
            if len(b) > 0:
                c = sum(b) / len(b)
            else:
                c = 0
            a.append(c)
        if len(a) > 0:
            return sum(a) / len(a)
        else:
            return 0
    

    В этом случаец код будет считать среднюю длину полос, состоящих из нулей.

  7. User

    А мне надо, чтобы считало длину полос, состоящую из единиц

  8. Assistant

    Понял, извините за недоразумение. Для того, чтобы код считал длину полос, состоящую из единиц, нам необходимо адаптировать функцию Len_array следующим образом:

    def Len_array(data):
        a = []
        for i in range(data.shape[0]):
            b = []
            count = 0
            for j in range(data.shape[1]):
                if data[i, j] == 1:
                    count += 1
                elif data[i, j] != 1:
                    if count > 10:
                        b.append(count)
                    count = 0
            if len(b) > 0:
                c = sum(b) / len(b)
            else:
                c = 0
            a.append(c)
        if len(a) > 0:
            return sum(a) / len(a)
        else:
            return 0
    

    Здесь мы оставляем условие data[i, j] == 1, чтобы учитывать только длину полос, состоящих из единиц. Теперь функция будет правильно считать среднюю длину полос, состоящих из единиц.