Учитывая 4 вершины, представляющие четырехугольник, как я могу разделить его на N частей? - PullRequest
Новая
       31

Учитывая 4 вершины, представляющие четырехугольник, как я могу разделить его на N частей?

0 голосов
/ 15 декабря 2018

Я пытаюсь, учитывая два измерения (ширину и высоту), которые представляют четырехугольник, разделение на четыре части, составляющее N частей, где каждая часть настолько пропорциональна, насколько это возможно.

ДляНапример, представьте себе лист бумаги.Он состоит из 4 точек A, B, C, D Теперь рассмотрим, что лист бумаги имеет размеры 800 x 800 и точки: 

A: {0, 0}
B: {0, 800}
C: {800, 800}
D: {800, 0}

График, который даст вам 4 точки или 3 линии с линейным графиком.Добавьте дополнительную точку E: {0, 0}, чтобы закрыть ячейку.

Мне удалось сделать это программно, для N числа ячеек.К сожалению, по какой-то причине, когда я устанавливаю N=4, я получаю 8 ячеек ... Я зажарен и не могу разобраться, и поэтому я ищу три вещи:

  • A)Как я могу улучшить этот код, чтобы сделать его более читабельным?
  • B) Как я могу улучшить этот код, чтобы сделать его более питоническим?
  • C) Вы догадались.Как исправить проблему N=4?

Код в полном объеме: 

import matplotlib.pyplot as plt


class QuadPartitioner:

    @staticmethod
    def get_factors(number):
        '''
        Takes a number and returns a list of factors
        :param number: The number for which to find the factors
        :return: a list of factors for the given number
        '''
        facts = []
        for i in range(1, number + 1):
            if number % i == 0:
                facts.append(i)
        return facts

    @staticmethod
    def get_partitions(N, quad_width, quad_height):

        '''
        Given a width and height, partition the area into N parts
        :param N: The number of partitions to generate
        :param quad_width: The width of the quadrilateral
        :param quad_height: The height of the quadrilateral
        :return: a list of a list of cells where each cell is defined as a list of 5 verticies
        '''

        # We reverse only because my brain feels more comfortable looking at a grid in this way
        factors = list(reversed(QuadPartitioner.get_factors(N)))

        # We need to find the middle of the factors so that we get cells
        # with as close to equal width and heights as possible
        split = int(len(factors)/2)
        factors = factors[split-1:split+1]

        # The width and height of an individual cell
        cell_width = quad_width / factors[0]
        cell_height = quad_height / factors[1]

        number_of_cells_in_a_row = factors[0]
        rows = factors[1]
        row_of_cells = []

        # We build just a single row of cells
        # then for each additional row, we just duplicate this row and offset the cells
        for n in range(0, number_of_cells_in_a_row):
                cell_points = []

                for i in range(0, 5):

                    cell_y = 0
                    cell_x = n * cell_width

                    if i == 2 or i == 3:
                        cell_x = n * cell_width + cell_width

                    if i == 1 or i == 2:
                        cell_y = cell_height

                    cell_points.append((cell_x, cell_y))

                row_of_cells.append(cell_points)

        rows_of_cells = [row_of_cells]

        # With that 1 row of cells constructed, we can simply duplicate it and offset it
        # by the height of a cell multiplied by the row number
        for index in range(1, rows):
            new_row_of_cells = [[ (point[0],point[1]+cell_height*index) for point in square] for square in row_of_cells]
            rows_of_cells.append(new_row_of_cells)

        return rows_of_cells


if __name__ == "__main__":

    QP = QuadPartitioner()
    partitions = QP.get_partitions(4, 800,800)

    for row_of_cells in partitions:
        for cell in row_of_cells:
            x, y = zip(*cell)
            plt.plot(x, y, marker='o')

    plt.show()

1 Ответ

0 голосов
/ 16 декабря 2018

Я исправил это, изменив: 

split = int(len(factors)/2)
factors = factors[split-1:split+1]

на: 

factor_count = len(factors)

if factor_count % 2 == 0:
    split = int(factor_count/2)
    factors = factors[split-1:split+1]
else:
    factors = []
    split = ceil(factor_count/2)
    factors.append(split)
    factors.append(split)
...