added front end and updated files

mysite/plots/avl_tree.py

@@ -8,6 +8,7 @@ import sys
 
 # Create a tree node
 class TreeNode(object):
+
     def __init__(self, key, vertice, vertice_neighbour):
         self.key = key
         self.vertice = vertice
@@ -184,4 +185,15 @@ class AVLTree(object):
                 indent += "|    "
             print(currPtr.key)
             self.printHelper(currPtr.left, indent, False)
-            self.printHelper(currPtr.right, indent, True)
\ No newline at end of file
+            self.printHelper(currPtr.right, indent, True)
+
+# myTree = AVLTree()
+# root = None
+# nums = [33, 13, 52, 9, 21, 61, 8, 11]
+# for num in nums:
+#     root = myTree.insert_node(root, num)
+# myTree.printHelper(root, "", True)
+# key = 13
+# root = myTree.delete_node(root, key)
+# print("After Deletion: ")
+# myTree.printHelper(root, "", True)
\ No newline at end of file

mysite/plots/dataset_creator.py

+# import pandas as pd
+# from .packing_algo import ConvexPolygon, pack_polygons, truncate, End_Container, plot_containers, ConvexContainer
+# from .polygon_creator import voronoi_polygons_wrapper, rectangle_cutter
+#
+#
+# # def build_aprox_factors():
+#
+#
+# def build_dataset_with_rectangle_cutter(rect_width: float, rect_height, repetition, angle_steps=90, cut_min=1,
+#                                         cut_max=1, cut_steps=1, intervals=[0, 0.01, 0.05, 1], weights=[0, 0, 0.5, 1]):
+#     if cut_min > cut_max:
+#         cut_max = cut_min
+#     data_dict_list = []
+#     for cut_count in range(cut_min, cut_max + cut_steps, cut_steps):
+#         cutted_polygons_lists = []
+#         for n in range(0, repetition):
+#             cutted_polygons = rectangle_cutter(rect_width, rect_height, cut_count, intervals=intervals, weights=weights)
+#             cutted_polygons_lists.append(cutted_polygons)
+#         dict_data = collect_rect_containers_data(rect_width, rect_height, cutted_polygons_lists, angle_steps)
+#         data_dict_list.append(dict_data)
+#     return data_dict_list
+#
+#
+# def build_dataset_with_voronoi(rect_width, rect_height, repetition, cut_min=5, cut_max=5, cut_steps=1, angle_steps=90):
+#     if cut_min > cut_max:
+#         cut_max = cut_min
+#     data_dict_list = []
+#     for cut_count in range(cut_min, cut_max + cut_steps, cut_steps):
+#         cutted_polygons_lists = []
+#         for n in range(0, repetition):
+#             cutted_polygons = voronoi_polygons_wrapper(rect_width, rect_height, cut_count)
+#             cutted_polygons_lists.append(cutted_polygons)
+#         dict_data = collect_rect_containers_data(rect_width, rect_height, cutted_polygons_lists, angle_steps)
+#         data_dict_list.append(dict_data)
+#     return data_dict_list
+#
+#
+# def collect_rect_containers_data(rect_width: float, rect_height: float, cutted_polygons_lists: [[ConvexPolygon]],
+#                                  angle_steps=90) -> {str, list}:
+#     opt_area = rect_width * rect_height
+#     opt_area_list = []
+#     area_list = []
+#     area_div_list = []
+#     angle_0_area_div_list = []
+#     angle_0_not_clipped_area_div_list = []
+#     not_clipped_area_list = []
+#     not_clipped_area_div_list = []
+#     polygon_count_list = []
+#     end_container_list = []
+#     mini_container_count_list = []
+#     for polygons in cutted_polygons_lists:
+#         cc = ConvexContainer(polygons, steps=angle_steps)
+#         end_container = cc.smallest_end_container
+#         end_container_angle_0 = cc.angle_0_end_container
+#
+#         c_area = end_container.container_area
+#         c_not_opt_area = end_container.container_not_clipped_area
+#         c_not_r_area = end_container_angle_0.container_area
+#         c_not_r_not_opt_area = end_container_angle_0.container_not_clipped_area
+#         area_list.append(truncate(c_area, 1))
+#         area_div_list.append(truncate(c_area / opt_area, 1))
+#         not_clipped_area_list.append(truncate(c_not_opt_area, 1))
+#         not_clipped_area_div_list.append(truncate(c_not_opt_area / opt_area, 1))
+#
+#         angle_0_area_div_list.append(truncate(c_not_r_area / opt_area, 1))
+#         angle_0_not_clipped_area_div_list.append(truncate(c_not_r_not_opt_area / opt_area, 1))
+#         opt_area_list.append(opt_area)
+#         polygon_count_list.append(len(polygons))
+#         mini_container_count_list.append(len(end_container.mini_containers))
+#         end_container_list.append(cc)
+#     rect_containers_data_dict = {'area': area_list, 'area/opt_area': area_div_list,
+#                                  'not_clipped_area': not_clipped_area_list,
+#                                  'not_clipped_area/opt_area': not_clipped_area_div_list,
+#                                  'angle_0_area/opt_area': angle_0_area_div_list,
+#                                  'angle_0_not_clipped_area/opt_area': angle_0_not_clipped_area_div_list,
+#                                  'opt-area': opt_area_list, 'polygon count': polygon_count_list,
+#                                  'mini-container count': mini_container_count_list, 'end-container': end_container_list}
+#     return rect_containers_data_dict
+#
+#
+# # need to update like rectangle_cutter with deviation
+# def find_repition_factor_rectangle_voronoi(cut, rep_high, rep_low=1, rep_steps=1, display_flag=True,
+#                                            intervals=[0, 0.01, 0.05, 1], weights=[0, 0, 0.5, 1]):
+#     average_list = []
+#     if rep_low < 1 or rep_high < 1:
+#         raise ValueError("the value of rep_high and rep_low need to bigger then 0")
+#     for rep in range(rep_low, rep_high + rep_steps, rep_steps):
+#         data = build_dataset_with_voronoi(1000, 1000, rep, cut_min=cut, cut_max=cut, cut_steps=1)
+#         df = pd.DataFrame(data[0])
+#         if display_flag:
+#             display(df.sort_values(by="area", ascending=False))
+#         list_optimal_areas = df["area/opt_area"].tolist()
+#         average = sum(list_optimal_areas) / len(list_optimal_areas)
+#         average_list.append((rep, average))
+#     return average_list
+#
+#
+# # deviation=0.05, accept=10
+# def find_repition_factor_rectangle_cutter(cut, rep_high, deviation=0.05, accept_number=10, rep_low=1, rep_steps=1,
+#                                           display_flag=True, intervals=[0, 0.01, 0.05, 1], weights=[0, 0, 0.5, 1]):
+#     average_list = []
+#     if rep_low < 1 or rep_high < 1:
+#         raise ValueError("the value of rep_high and rep_low need to bigger then 0")
+#     average_canidate = 0
+#     accept_counter = accept_number
+#     average_top_bound = average_canidate + average_canidate * deviation
+#     average_bot_bound = average_canidate - average_canidate * deviation
+#     for rep in range(rep_low, rep_high + rep_steps, rep_steps):
+#
+#         data = build_dataset_with_rectangle_cutter(1000, 1000, rep, cut_min=cut, cut_max=cut, cut_steps=1,
+#                                                    intervals=[0, 0.01, 0.05, 1], weights=[0, 0, 0.5, 1])
+#         df = pd.DataFrame(data[0])
+#         if display_flag:
+#             display(df.sort_values(by="area", ascending=False))
+#
+#         list_optimal_areas = df["area/opt_area"].tolist()
+#         average = sum(list_optimal_areas) / len(list_optimal_areas)
+#
+#         if average_bot_bound <= average <= average_top_bound:
+#             accept_counter -= 1
+#         else:
+#             average_canidate = average
+#             accept_counter = accept_number
+#             average_top_bound = average_canidate + average_canidate * deviation
+#             average_bot_bound = average_canidate - average_canidate * deviation
+#         if accept_counter <= 0:
+#             print(rep)
+#             return average_list
+#         average_list.append((rep, average))
+#     return average_list
+#
+#
+# def dict_list_to_ordered_panda_list(dictionary_list: [dict], ordered_by_area=True) -> [pd.DataFrame]:
+#     data_frame_list = []
+#     for dic in dictionary_list:
+#         df = pd.DataFrame(dic)
+#         if ordered_by_area:
+#             data_frame_list.append(df.sort_values(by="area", ascending=False))
+#         else:
+#             data_frame_list.append(df.sort_values(by="not_clipped_area", ascending=False))
+#     return data_frame_list
+#
+#
+# def display_panda_df_list(df_list: [pd.DataFrame]) -> None:
+#     for df in df_list:
+#         display(df)
+#
+#
+# def build_aprox_values(panda_data):
+#     mean_opt = 0
+#     mean_not_clipped = 0
+#     mean_angle_0 = 0
+#     mean_angle_0_not_clipped = 0
+#     counter = 0
+#     mean_best = 0
+#     mean_worst = 0
+#     for data in panda_data:
+#         mean_opt += data["area/opt_area"].mean(axis=0)
+#         mean_best += data["area/opt_area"].iloc[-1]
+#         mean_worst += data["area/opt_area"].iloc[0]
+#         mean_not_clipped += data["not_clipped_area/opt_area"].mean(axis=0)
+#         mean_angle_0 += data["angle_0_area/opt_area"].mean(axis=0)
+#         mean_angle_0_not_clipped += data["angle_0_not_clipped_area/opt_area"].mean(axis=0)
+#         counter += 1
+#     mean_opt = mean_opt / counter
+#     mean_best = mean_best / counter
+#     mean_worst = mean_worst / counter
+#     mean_not_clipped = mean_not_clipped / counter
+#     mean_angle_0 = mean_angle_0 / counter
+#     mean_angle_0_not_clipped = mean_angle_0_not_clipped / counter
+#     aprox_dict = dict(aprox=mean_opt, aprox_best=mean_best, aprox_worst=mean_worst, aprox_not_clipped=mean_not_clipped,
+#                       aprox_angle_0=mean_angle_0, aprox_angle_0_not_clipped=mean_angle_0_not_clipped)
+#     return aprox_dict
\ No newline at end of file

mysite/plots/plot_helpers.py

-import math
-from django.shortcuts import render
-from plotly.offline import plot
-import plots.polygon as poly
-from django.http import JsonResponse
-from plotly.graph_objs import Scatter
-import plotly.graph_objects as go
-from django.http import HttpResponse
-import pdb; pdb.set_trace
-from plotly.subplots import make_subplots
-import math
-
-def polygon_plot(polygons):
-    plot_polygon_list = []
-
-    polygon_count = len(polygons)
-    cols = 4
-    rows = math.ceil(polygon_count / cols)
-    number = 0
-    sub_plot_titles = ['{}   height:{}  slope:{}'.format(number,
-                                                         (int(polygons[number].height * 10)) / 10,
-                                                         (int(polygons[number].slope * 10)) / 10)
-                        for number in range(0, polygon_count)]
-
-    fig = make_subplots(rows=rows, cols=cols, subplot_titles=sub_plot_titles)
-    fig.update_layout(title="Convex Polygons")
-    counter = 0
-    for polygon in polygons:
-        x_data = polygon.x_values
-        y_data = polygon.y_values
-        scatter = go.Scatter(x=x_data, y=y_data,
-                             mode='lines', name='{}'.format(counter),
-                             opacity=0.8, marker_color='green')
-
-        spine_x_values = [x[0] for x in polygon.spine]
-        spine_y_values = [x[1] for x in polygon.spine]
-        scatter_spine = go.Scatter(x=spine_x_values, y=spine_y_values,
-                                   mode='lines', name='{} Spine'.format(counter),
-                                   opacity=0.8, marker_color='red')
-        row = math.ceil((counter + 1) / cols)
-        col = (counter % cols) + 1
-        fig.add_trace(scatter, row=row, col=col)
-        fig.add_trace(scatter_spine, row=row, col=col)
-        counter += 1
-    plot_polygons_div = plot(fig, output_type='div')
-    return plot_polygons_div
-
-def high_class_plot(high_classes):
-    plot_high_class_list = []
-    polygon_number = 0
-    polygon_title_number = 0
-    for hc in high_classes:
-        polygon_count = len(hc.polygons)
-        cols = 4
-        rows = math.ceil(polygon_count / cols)
-
-        # sub_plot_titles = ['{}   height:{}  slope:{}'.format(number,
-        #                                                      (int(hc.spine_ordered_polygons[number].height * 10)) / 10,
-        #                                                      (int(hc.spine_ordered_polygons[number].slope * 10)) / 10)
-        #                     for number in range(0, polygon_count)]
-        sub_plot_titles=[]
-        for polygon in hc.spine_ordered_polygons:
-
-            sub_plot_titles.append('{}   height:{}  slope:{}'.format(polygon_title_number, (int(polygon.height*10))/10,(int(polygon.slope * 10)) / 10))
-            polygon_title_number += 1
-        fig = make_subplots(rows=rows, cols=cols, subplot_titles=sub_plot_titles)
-        fig.update_layout(title="Highclass {}   heights: {}-{}".format(hc.i, int(hc.min_border), int(hc.max_border)))
-        counter = 0
-
-        for polygon in hc.spine_ordered_polygons:
-            x_data = polygon.x_values
-            y_data = polygon.y_values
-            scatter = go.Scatter(x=x_data, y=y_data,
-                                 mode='lines', name='{}'.format(polygon_number),
-                                 opacity=0.8, marker_color='green')
-
-            spine_x_values = [x[0] for x in polygon.spine]
-            spine_y_values = [x[1] for x in polygon.spine]
-            scatter_spine = go.Scatter(x=spine_x_values, y=spine_y_values,
-                                       mode='lines', name='{} Spine'.format(polygon_number),
-                                       opacity=0.8, marker_color='red')
-            row = math.ceil((counter + 1) / cols)
-            col = (counter % cols) + 1
-            fig.add_trace(scatter, row=row, col=col)
-            fig.add_trace(scatter_spine, row=row, col=col)
-            counter += 1
-            polygon_number += 1
-        plt_div = plot(fig, output_type='div')
-        plot_high_class_list.append(plt_div)
-    return plot_high_class_list
-
-
+# import math
+# from django.shortcuts import render
+# from plotly.offline import plot
+# import plots.polygon as poly
+# from django.http import JsonResponse
+# from plotly.graph_objs import Scatter
+# import plotly.graph_objects as go
+# from django.http import HttpResponse
+# import pdb; pdb.set_trace
+# from plotly.subplots import make_subplots
+# import math
+#
+# def polygon_plot(polygons):
+#     plot_polygon_list = []
+#
+#     polygon_count = len(polygons)
+#     cols = 4
+#     rows = math.ceil(polygon_count / cols)
+#     number = 0
+#     sub_plot_titles = ['{}   height:{}  slope:{}'.format(number,
+#                                                          (int(polygons[number].height * 10)) / 10,
+#                                                          (int(polygons[number].slope * 10)) / 10)
+#                         for number in range(0, polygon_count)]
+#
+#     fig = make_subplots(rows=rows, cols=cols, subplot_titles=sub_plot_titles)
+#     fig.update_layout(title="Convex Polygons")
+#     counter = 0
+#     for polygon in polygons:
+#         x_data = polygon.x_values
+#         y_data = polygon.y_values
+#         scatter = go.Scatter(x=x_data, y=y_data,
+#                              mode='lines', name='{}'.format(counter),
+#                              opacity=0.8, marker_color='green')
+#
+#         spine_x_values = [x[0] for x in polygon.spine]
+#         spine_y_values = [x[1] for x in polygon.spine]
+#         scatter_spine = go.Scatter(x=spine_x_values, y=spine_y_values,
+#                                    mode='lines', name='{} Spine'.format(counter),
+#                                    opacity=0.8, marker_color='red')
+#         row = math.ceil((counter + 1) / cols)
+#         col = (counter % cols) + 1
+#         fig.add_trace(scatter, row=row, col=col)
+#         fig.add_trace(scatter_spine, row=row, col=col)
+#         counter += 1
+#     plot_polygons_div = plot(fig, output_type='div')
+#     return plot_polygons_div
+#
+# def high_class_plot(high_classes):
+#     plot_high_class_list = []
+#     polygon_number = 0
+#     polygon_title_number = 0
+#     for hc in high_classes:
+#         polygon_count = len(hc.polygons)
+#         cols = 4
+#         rows = math.ceil(polygon_count / cols)
+#
+#         # sub_plot_titles = ['{}   height:{}  slope:{}'.format(number,
+#         #                                                      (int(hc.spine_ordered_polygons[number].height * 10)) / 10,
+#         #                                                      (int(hc.spine_ordered_polygons[number].slope * 10)) / 10)
+#         #                     for number in range(0, polygon_count)]
+#         sub_plot_titles=[]
+#         for polygon in hc.spine_ordered_polygons:
+#
+#             sub_plot_titles.append('{}   height:{}  slope:{}'.format(polygon_title_number, (int(polygon.height*10))/10,(int(polygon.slope * 10)) / 10))
+#             polygon_title_number += 1
+#         fig = make_subplots(rows=rows, cols=cols, subplot_titles=sub_plot_titles)
+#         fig.update_layout(title="Highclass {}   heights: {}-{}".format(hc.i, int(hc.min_border), int(hc.max_border)))
+#         counter = 0
+#
+#         for polygon in hc.spine_ordered_polygons:
+#             x_data = polygon.x_values
+#             y_data = polygon.y_values
+#             scatter = go.Scatter(x=x_data, y=y_data,
+#                                  mode='lines', name='{}'.format(polygon_number),
+#                                  opacity=0.8, marker_color='green')
+#
+#             spine_x_values = [x[0] for x in polygon.spine]
+#             spine_y_values = [x[1] for x in polygon.spine]
+#             scatter_spine = go.Scatter(x=spine_x_values, y=spine_y_values,
+#                                        mode='lines', name='{} Spine'.format(polygon_number),
+#                                        opacity=0.8, marker_color='red')
+#             row = math.ceil((counter + 1) / cols)
+#             col = (counter % cols) + 1
+#             fig.add_trace(scatter, row=row, col=col)
+#             fig.add_trace(scatter_spine, row=row, col=col)
+#             counter += 1
+#             polygon_number += 1
+#         plt_div = plot(fig, output_type='div')
+#         plot_high_class_list.append(plt_div)
+#     return plot_high_class_list
+#
+#

mysite/plots/polygon_creator.py

+# Zerlegen des Polygons
+#import import_ipynb
+
+# Voronoi diagramm
+import scipy.spatial as spatial
+from collections import defaultdict
+import random
+import numpy
+from shapely.geometry import Polygon, MultiPolygon
+from .packing_algo import ConvexPolygon, Point_xy, plot_polygons_in_single_plot
+
+
+def rectangle_cutter(rect_width: float, rect_height: float, cut_count: int, intervals=[0, 0.01, 0.05, 1],
+                     weights=[0, 0, 0.5, 1], render=False,
+                     plot_width=700, plot_height=700) -> [ConvexPolygon]:
+    if len(intervals) != len(weights):
+        raise ValueError("the number of values from weights and intervals need to be the same")
+    rectangle_polygon = ConvexPolygon([(0, 0), (0, rect_height), (rect_width, rect_height), (rect_width, 0), (0, 0)])
+    max_area = rect_width * rect_height
+    small_area_polygons = []
+    polygons_to_cut = [rectangle_polygon]
+    if cut_count < 0:
+        raise ValueError("the cut cut_count need to be positive to cut the polygon")
+    while cut_count > 0 and len(polygons_to_cut) > 0:
+        cutted_polygons = []
+        for polygon in polygons_to_cut:
+            related_area = polygon.area / max_area
+            weight = find_weight(related_area, intervals, weights)
+            rand = random.random()
+            if rand <= weight:
+                cutted_polygons = cutted_polygons + cut_polygon(polygon)
+            else:
+                polygon.plot_fill = True
+                small_area_polygons.append(polygon)
+        polygons_to_cut = cutted_polygons
+        cut_count = cut_count - 1
+        if render:
+            current_polygons = polygons_to_cut + small_area_polygons
+            title = "Rectangle to Polygons=P.  cut_count: {}  P. count: {}  P. to cut: {}  P. stopped cutting: {}".format(
+                cut_count, len(current_polygons), len(polygons_to_cut), len(small_area_polygons))
+            fig = plot_polygons_in_single_plot(current_polygons, title=title, plot_width=plot_width,
+                                               plot_height=plot_height)
+    all_polygons = polygons_to_cut + small_area_polygons
+    if render:
+        for polygon in all_polygons:
+            polygon.plot_fill = False
+    return all_polygons
+
+
+def find_weight(x, intervals, weights):
+    for index in range(0, len(intervals)):
+        if x <= intervals[index]:
+            return weights[index]
+
+
+def cut_polygon(polygon: ConvexPolygon) -> [ConvexPolygon]:
+    polygon = polygon.shell  # polyog
+    number_vertices = len(polygon)
+    if number_vertices < 3:
+        raise ValueError("Polygon has not enough vertices")
+    first_edge = numpy.random.randint(1, number_vertices)
+    second_edge = numpy.random.randint(1, number_vertices)
+    while first_edge == second_edge:
+        second_edge = numpy.random.randint(1, number_vertices)
+    if first_edge > second_edge:
+        first_edge, second_edge = second_edge, first_edge
+    vertex_1_first_edge = polygon[first_edge - 1]
+    vertex_2_first_edge = polygon[first_edge]
+    vertex_1_second_edge = polygon[second_edge - 1]
+    vertex_2_second_edge = polygon[second_edge]
+
+    new_vertex_1 = random_point_between_edge(vertex_1_first_edge, vertex_2_first_edge)
+    new_vertex_2 = random_point_between_edge(vertex_1_second_edge, vertex_2_second_edge)
+    polygon_1 = polygon[:first_edge] + [new_vertex_1] + [new_vertex_2] + polygon[second_edge:]
+    polygon_2 = [new_vertex_1] + polygon[first_edge:second_edge] + [new_vertex_2] + [new_vertex_1]
+    #  s = [1,2,5,6,7] ,s[6:] => []; daher können wir für den spezial Fall second_edge== vertices_number so vorgehen
+    return [ConvexPolygon(polygon_1), ConvexPolygon(polygon_2)]
+
+
+def random_point_between_edge(vertex_1: Point_xy, vertex_2: Point_xy) -> Point_xy:
+    new_vertex = (0, 0)
+    if vertex_1[0] == vertex_2[0]:
+        low, high = vertex_1[1], vertex_2[1]
+        if low > high:
+            low, high = high, low
+        rand_number = numpy.random.uniform(low, high)
+        new_vertex = (vertex_1[0], rand_number)
+    elif vertex_1[1] == vertex_2[1]:
+        low, high = vertex_1[0], vertex_2[0]
+        if low > high:
+            low, high = high, low
+        rand_number = numpy.random.uniform(low, high)
+        new_vertex = (rand_number, vertex_1[1])
+    else:
+        # y = m*x+n
+        # n = y-m*x
+        slope = (vertex_1[1] - vertex_2[1]) / (vertex_1[0] - vertex_2[
+            0])  # m = y2-y1/x2-x1 Formel für die Geradensteigung mithilfe aus zwei verschiedenen Punkten der Geraden
+        n = vertex_1[1] - (slope * vertex_1[0])
+        low, high = vertex_1[1], vertex_2[1]
+        if low > high:
+            low, high = high, low
+        rand_number = numpy.random.uniform(low, high)
+        new_vertex_x = (rand_number - n) / slope  # x=(y-n)/m
+        new_vertex = (new_vertex_x, rand_number)
+    return new_vertex
+
+
+# https://gist.github.com/pv/8036995
+# https://stackoverflow.com/questions/20515554/colorize-voronoi-diagram/20678647#20678647
+def voronoi_polygons_wrapper(rect_width, rect_height, point_count):
+    boundary = numpy.array([[0, 0], [0, rect_height], [rect_width, rect_height], [rect_width, 0], [0, 0]])
+    boundary_polygon = Polygon(boundary)
+
+    x_values = numpy.random.uniform(low=0 + 1, high=rect_width - 1, size=(point_count,))
+    y_values = numpy.random.uniform(low=0 + 1, high=rect_height - 1, size=(point_count,))
+    points = list(zip(x_values, y_values))
+    bigger = max(rect_width, rect_height)
+    pre_number = pre_decimal_finder(bigger) + 3
+    border_point = int(str(9) * pre_number)
+    help_border = [[border_point, border_point], [-border_point, border_point], [border_point, -border_point],
+                   [-border_point, -border_point]]
+    points = numpy.append(points, help_border, axis=0)
+    # compute Voronoi tesselation
+    vor = spatial.Voronoi(points)
+    polygon_list = []
+    for region in vor.regions:
+        if not -1 in region:
+            polygon = [vor.vertices[i] for i in region]
+            if len(polygon) > 2:
+                # Clipping polygon
+                poly = Polygon(polygon)
+                clipped_poly = poly.intersection(boundary_polygon)
+                polygon_list.append(ConvexPolygon(clipped_poly.exterior.coords))
+    return polygon_list
+
+
+def pre_decimal_finder(i: float) -> int:
+    if i < 0:
+        i = abs(i)
+    counter = 0
+    while i != 0:
+        i = i // 10
+        counter += 1
+    return counter

mysite/plots/templates/plots/index0.html

@@ -9,7 +9,7 @@
 <div>
 {% autoescape off %}
 
-<h1>Polygons</h1>
+<h1>Packed Polygons Steps</h1>
 {{polygons_plot}}
   {{polygons_plot.}}
 <hr>

mysite/plots/templates/plots/index_new.html

+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>test</title>
+</head>
+<body>
+<div>
+{% autoescape off %}
+
+<h1>Polygons</h1>
+{{plot_steps}}
+{% endautoescape %}
+</div>
+</body>
+</html>
\ No newline at end of file

mysite/plots/templates/plots/tab.html

-<!DOCTYPE html>
-<html>
-<head>
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<style>
-body {font-family: Arial;}
-
-/* Style the tab */
-.tab {
-  overflow: hidden;
-  border: 1px solid #ccc;
-  background-color: #f1f1f1;
-}
-
-/* Style the buttons inside the tab */
-.tab button {
-  background-color: inherit;
-  float: left;
-  border: none;
-  outline: none;
-  cursor: pointer;
-  padding: 14px 16px;
-  transition: 0.3s;
-  font-size: 17px;
-}
-
-/* Change background color of buttons on hover */
-.tab button:hover {
-  background-color: #ddd;
-}
-
-/* Create an active/current tablink class */
-.tab button.active {
-  background-color: #ccc;
-}
-
-/* Style the tab content */
-.tabcontent {
-  display: none;
-  padding: 6px 12px;
-  border: 1px solid #ccc;
-  border-top: none;
-}
-</style>
-</head>
-<body>
-
-<h2>Tabs</h2>
-<p>Click on the buttons inside the tabbed menu:</p>
-
-<div class="tab">
-  <button class="tablinks" onclick="openCity(event, 'London')">London</button>
-  <button class="tablinks" onclick="openCity(event, 'Paris')">Paris</button>
-  <button class="tablinks" onclick="openCity(event, 'Tokyo')">Tokyo</button>
-</div>
-
-<div id="London" class="tabcontent">
-  <h3>London</h3>
-  <p>London is the capital city of England.</p>
-</div>
-
-<div id="Paris" class="tabcontent">
-  <h3>Paris</h3>
-  <p>Paris is the capital of France.</p>
-</div>
-
-<div id="Tokyo" class="tabcontent">
-  <h3>Tokyo</h3>
-  <p>Tokyo is the capital of Japan.</p>
-</div>
-
-<script>
-function openCity(evt, cityName) {
-  var i, tabcontent, tablinks;
-  tabcontent = document.getElementsByClassName("tabcontent");
-  for (i = 0; i < tabcontent.length; i++) {
-    tabcontent[i].style.display = "none";
-  }
-  tablinks = document.getElementsByClassName("tablinks");
-  for (i = 0; i < tablinks.length; i++) {
-    tablinks[i].className = tablinks[i].className.replace(" active", "");
-  }
-  document.getElementById(cityName).style.display = "block";
-  evt.currentTarget.className += " active";
-}
-</script>
-
-</body>
-</html>

mysite/plots/templates/plots/test.html

@@ -3,25 +3,12 @@
     <head>
         <meta charset="utf-8">
         <title></title>
-
-        <style>
-          html {
-            width: 100%;
-            height: 100%;
-          }
-          body {
-            width: 90%;
-            height: 100%;
-            margin: auto;
-          }
-        </style>
-        <script>
-            function change_ds_value(name, idx, value) {
-                var ds = Bokeh.documents[0].get_model_by_name('my-data-source');
-                ds.data[name][idx] = value;
-                ds.change.emit();
-            }
-        </script>
+        <script src="https://cdn.bokeh.org/bokeh/release/bokeh-2.2.3.min.js"
+        crossorigin="anonymous"></script>
+        <script src="https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.2.3.min.js"
+                crossorigin="anonymous"></script>
+        <script src="https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.2.3.min.js"
+                crossorigin="anonymous"></script>
     </head>
     <body>
 
@@ -29,22 +16,53 @@
         <div>
             {{ response|safe }}
             <form action="/test/"  method="post">
-        {% csrf_token %}
-        <label for="your_name"></label>
-    <input id="your_name" type="hidden" name="your_name" value="test">
-    <input type="submit" onclick="myFunction()" value="Load Polygons">
-    </form>
-            <!--{{response4|safe}}-->
+                {% csrf_token %}
+                <label for="your_name">Load the input Polygons</label>
+                <input id="your_name" type="hidden" name="your_name" value="test">
+                <input type="submit" onclick="myFunction()" value="load">
+            </form>
         </div>
-
+        <div>
+            <form action="/packing_rect_container/" target="_blank"  method="get">
+                {% csrf_token %}
+                <label for="pack_rect_container">Packing Rectengular Container</label>
+                <input id="pack_rect_container" type="hidden" name="pack_polygon" value="test">
+                <input type="submit" onclick="packPolygons()" value="pack">
+            </form>
+        </div>
+         <div>
+            <form action="/packing_rotated_rect_container/" target="_blank"  method="get">
+                {% csrf_token %}
+                <label for="pack_rotated_rect_container">Packing Rotated Rectengular Container</label>
+                <input id="pack_rotated_rect_container" type="hidden" name="pack_polygon" value="test">
+                <input type="submit" onclick="packPolygons()" value="pack">
+            </form>
+        </div>
+        <div>
+            <form action="/packing_convex_container/" target="_blank"  method="post">
+                {% csrf_token %}
+                <label for="pack_convex_container">Packing Convex Container (degree between 1-360)</label>
+                <input id="pack_convex_container" type="number" min="1" max="360" name="angle" value=10>
+                <input type="submit"  value="pack">
+            </form>
+        </div>
+        <div>
+        {% autoescape off %}
+            <h1>Convex Polygons</h1>
             {{polygons_plot|safe}}
+            <h1>Convex Polygons in one Plot</h1>
             {{polygons_single_plot|safe}}
+
+
+        {% endautoescape %}
+        </div>
+
+
     </body>
-<script type="text/javascript">
 
-var element = document.getElementById("your_name");
-element.value = "{{response}}";
-</script>
+
+
+
 <script>
 function myFunction() {
   var ds = Bokeh.documents[0].get_model_by_name('my-data-source');

mysite/plots/urls.py

 from django.urls import path
-from plots.views import PolygonEditView
+from plots.views import PolygonEditView, PackingRectContainer, PackingRotatedRectContainer, PackingConvexContainer
 from . import views
 
 urlpatterns = [
     path('plot/', views.index, name='index'),
-    path('json/', views.get_json_view, name='index2'),
+    #path('json/', views.get_json_view, name='index2'),
     #path('test/', views.test, name='index3'),
-    path('hello/', views.hello, name='index4'),
+    #path('hello/', views.hello, name='index4'),
     path('test/', PolygonEditView.as_view(), name='index4'),
+    path('packing_rect_container/', PackingRectContainer.as_view(), name='rect_container'),
+    path('packing_rotated_rect_container/', PackingRotatedRectContainer.as_view(), name='rotated_rect_container'),
+    path('packing_convex_container/', PackingConvexContainer.as_view(), name='convex_container'),
 ]
\ No newline at end of file

mysite/plots/views.py

@@ -6,21 +6,20 @@ import json
 from django.shortcuts import render
 from django.views import View
 
-from plotly.offline import plot
+
 from django.http import HttpResponseRedirect
-import plots.polygon as poly
+import plots.packing_algo as poly
 from bokeh.embed import file_html
 from bokeh.models import BoxZoomTool
 from django.views.generic import TemplateView
 import matplotlib
 from django.http import JsonResponse
-from plotly.graph_objs import Scatter
-import plotly.graph_objects as go
+
 from django.http import HttpResponse
 import pdb;pdb.set_trace
 import matplotlib.pyplot as plt
 import mpld3
-from plotly.subplots import make_subplots
+
 import math
 from plots import plot_helpers
 from bokeh.plotting import figure, output_file, show
@@ -43,246 +42,53 @@ from bokeh.models.callbacks import CustomJS
 from bokeh.embed import json_item
 import json
 
-def index(request):
-
-    convex_polygons = poly.create_multiple_convex_polygons(50,9)
-
-    polygons_plot= poly.plot_polygons(convex_polygons,plot_width=300,plot_height=300,render=False)
-    html_polygons = file_html(polygons_plot, CDN, "my plot")
-
-    high_classes = poly.height_classes(convex_polygons)
-
-    hc_tab_list = []
-
-    # building highclass plots
-    for counter,hc in enumerate(high_classes):
-        hc_plot = hc.plot_hc(render=False,plot_width=300,plot_height=300)
-        tab = Panel(child=hc_plot, title="High-Class {}".format(counter))
-        hc_tab_list.append(tab)
-    hc_tabs = Tabs(tabs=hc_tab_list)
-    hc_plot_helper = file_html(hc_tabs, CDN, "my plot")
-
-    list_containers = poly.building_containers(high_classes)
-    container_tab_list=[]
-
-    #building container plots
-    for counter,container in enumerate(list_containers):
-        container_plot = container.plot_container_steps(plot_width=500,colums=3,plot_height=500,render=False)
-        tab = Panel(child=container_plot, title="High-Class {} -> Container {}".format(counter, counter))
-        container_tab_list.append(tab)
-    tabs = Tabs(tabs=container_tab_list)
-    container_plot_helper= file_html(tabs, CDN, "my plot")
-
-
-    mini_containers_tuple = poly.pack_mini_containers(list_containers,plot_steps=True)
-    list_mini_containers = mini_containers_tuple[0]
-    mini_container_plots = mini_containers_tuple[1]
-    mini_plot = poly.plot_mini_containers(mini_container_plots,render=False)
 
+def index(request):
 
-    # building mini container plots
-    mini_plots_tabs=[]
-    for counter,m_plot in enumerate(mini_plot):
-        tab = Panel(child=m_plot, title="Container {} -> Mini-Containers".format(counter))
-        mini_plots_tabs.append(tab)
-    mini_tabs = Tabs(tabs=mini_plots_tabs)
-    mini_html_plots = file_html(mini_tabs, CDN, "my plot")
+    convex_polygons = poly.create_multiple_convex_polygons(10,9)
+    cc = poly.ConvexContainer(convex_polygons)
+    plot_steps = cc.plot_steps(render=False)
+    plot_steps_html = file_html(plot_steps, CDN, "my plot2")
 
-    # end container plot
-    end_container = poly.End_Container(list_mini_containers)
-    end_container_plot= end_container.plot_container(render=False)
-    end_container_html =file_html(end_container_plot, CDN, "my plot2")
-    return render(request, 'plots/index0.html', context={'polygons_plot': html_polygons,'hc_plot': hc_plot_helper,'container_plot': container_plot_helper,
-                                                        'mini_container_plot': mini_html_plots, 'end_container_plot':end_container_html})
+    return render(request, 'plots/index_new.html', context={"plot_steps":plot_steps_html})
 
                                                         # 'high_classes': plot_high_class_list,})
             #                                            'hc_container': hc_container})
 
+class PackingRectContainer(View):
+    def get(self, request, *args, **kwargs):
+        cc = poly.pack_polygons( PolygonEditView.polygons)
+        plot_steps = cc.plot_steps(render=False)
+        plot_steps_html = file_html(plot_steps, CDN, "my plot23")
+        #PackingPolygons.context["packed_polygons"]=plot_steps_html
+        return render(request, 'plots/index_new.html', context={"plot_steps": plot_steps_html})
 
 
+class PackingRotatedRectContainer(View):
+    def get(self, request, *args, **kwargs):
+        cc = poly.ConvexContainer(PolygonEditView.polygons,steps=90)
+        plot_steps = cc.plot_steps(render=False)
+        plot_steps_html = file_html(plot_steps, CDN, "my plot23")
+        # PackingPolygons.context["packed_polygons"]=plot_steps_html
+        return render(request, 'plots/index_new.html', context={"plot_steps": plot_steps_html})
 
 
-def get_json_view(request):
-    convex_polygons = poly.create_multiple_convex_polygons(14, 3)
-    #polygons_plot = poly.plot_polygons(convex_polygons, plot_width=300, plot_height=300, render=False)
-    #html_polygons = file_html(polygons_plot, CDN, "my plot")
-    list_hc = poly.height_classes(convex_polygons)
-    list_containers = poly.building_containers(list_hc)
-
-    tab_list=[]
-    counter=0
-    for container in list_containers:
-        container_plot = container.plot_container_steps(plot_width=500, colums=3, plot_height=500, render=False)
-        #tab1 = Panel(child=container_plot, title="High-Class {} -> Container {}".format(counter,counter))
-        tab_list.append(file_html(container_plot, CDN, "my plot"))
-        counter +=1
-    #html_container = file_html(tab_list, CDN, "my plot")
-
-    #container_plot_helper.append(html_container)
-    #tabs = Tabs(tabs=tab_list)
-    response =  tab_list
-
-    mini_containers_tuple = poly.pack_mini_containers(list_containers, plot_steps=True)
-    list_mini_containers = mini_containers_tuple[0]
-    mini_container_plots = mini_containers_tuple[1]
-
-    mini_plot = poly.plot_mini_containers(mini_container_plots, render=False)
-
-    mini_plots = []
-    tabs = []
-    for counter, m_plot in enumerate(mini_plot):
-
-        mini_plots.append(file_html(m_plot, CDN, "my plot"))
-        # tabs.append(Panel(child=m_plot, title="circle {}".format(counter)))
-    # tab =Tabs(tabs=tabs)
-    mini_html_plots = mini_plots
-
-    # fig1 = figure()
-    # fig1.circle([0, 1, 2], [1, 3, 2])
-    # fig2 = figure()
-    # fig2.circle([0, 0, 2], [4, -1, 1])
-    # fig3 = figure()
-    # fig3.circle([0, 4, 3], [1, 2, 0])
-    #
-    # l1 = layout([[fig1, fig2]])
-    # l2 = layout([[fig3]])
-    #
-    # tab1 = Panel(child=fig1, title="This is Tab 1")
-    # tab2 = Panel(child=fig2, title="This is Tab 2")
-    # tabs = Tabs(tabs=[tab1, tab2])
-    # response =file_html(tabs, CDN, "my plot")
-    #show(tabs)
-    return render(request, 'plots/get.html', context={'containers': response,'containers2':mini_plots})
-
-
-
-
-
-def test(request):
-    # source = ColumnDataSource(data=dict(x=[1, 2, 3],
-    #                                    y=[3, 2, 1]),
-    #                          name='my-data-source')
-    #
-    # p = figure()
-    # l1 = p.line("x", "y", source=source)
-    # response = file_html(p, CDN, "my plot")
-    # list =[1,2,3,4]
-    if request.method == "POST":
-        context={}
-        print(request.POST)
-        test = request.POST["your_name"]
-        dict_poly = json.loads(test)
-        print(dict_poly["x"])
-        print(dict_poly["y"])
-        polygon_list=[]
-        polygons_x_y_tuple = list(zip(dict_poly["x"],dict_poly["y"]))
-        # polygon_x_list = []
-        # polygon_y_list = []
-        for x,y in  polygons_x_y_tuple:
-            polygon_list.append(list(zip(x,y)))
-        # for x,y in polygons_x_y_tuple:
-        #     polygon_x_list.append(x)
-        #     polygon_y_list.append(y)
-        print(polygon_list)
-        real_polygons=[]
-        for polygon in polygon_list:
-
-            if len(polygon)<3:
-                continue
-            if polygon[0]!= polygon[-1]:
-                polygon.append(polygon[0])
-
-
-            polygon2 = poly.Polygon(polygon)
-            print("konkav",list(polygon2.exterior.coords))
-            polygon_parent_class = polygon2.convex_hull
-            polygon2 = poly.Polygon2(list(polygon_parent_class.exterior.coords))
-            print("convex",polygon2.shell)
-            real_polygons.append(polygon2)
-        # print(polygon_list)
-        # q = map(list, zip(*polygon_list))
-        # s=  json.loads(test)
-        # x = s["x"]
-        # y = s["y"]
-        # source = ColumnDataSource(data=dict(x=polygon_x_list, y=polygon_y_list),name='my-data-source')
-        # print(test)
-        plot = poly.plot_polygons_in_single_plot(real_polygons,render=False)
-        # plot = poly.plot_polygons(real_polygons,render=False)
-        # print(type(test))
-        # p = figure()
-        # p.multi_line("x", "y", source=source)
-        response2 = file_html(plot, CDN, "my plot")
-        context["response3"]=response2
-        return HttpResponseRedirect('/test/')
-    TOOLTIPS = [("index", "$index"), ("(x,y)", "($x{1.1}, $y{1.1})"), ]
-    source = ColumnDataSource(data=dict(x=[],
-                                       y=[]),
-                             name='my-data-source')
-
-    p = figure(x_range=(0, 10), y_range=(0, 10), width=400, height=400,
-               title='Poly Edit Tool',tooltips=TOOLTIPS)
-
-    p1 = p.patches("x", "y", fill_alpha=0.4,source=source, fill_color="red")
-
-    c1 = p.circle([],[], size=10, color='red', )
-
-    draw_tool = PolyDrawTool(renderers=[p1])
-    edit_tool = PolyEditTool(renderers=[p1], vertex_renderer=c1)
-    p.add_tools(draw_tool, edit_tool)
-    p.toolbar.active_drag = edit_tool
-    response = file_html(p, CDN, "my plot")
-    return render(request, 'plots/test.html', context={"response":response, "list":list})
-
-
-def hello(request):
-    if request.method == 'POST':
-        test = request.POST["your_name"]
-        dict_poly = json.loads(test)
-        print(dict_poly["x"])
-        print(dict_poly["y"])
-        polygon_list=[]
-        polygons_x_y_tuple = list(zip(dict_poly["x"],dict_poly["y"]))
-        # polygon_x_list = []
-        # polygon_y_list = []
-        for x,y in  polygons_x_y_tuple:
-            polygon_list.append(list(zip(x,y)))
-        # for x,y in polygons_x_y_tuple:
-        #     polygon_x_list.append(x)
-        #     polygon_y_list.append(y)
-        print(polygon_list)
-        real_polygons=[]
-        for polygon in polygon_list:
-
-            if len(polygon)<3:
-                continue
-            if polygon[0]!= polygon[-1]:
-                polygon.append(polygon[0])
-
+class PackingConvexContainer(View):
+    # context = {}
+    def get(self, request, *args, **kwargs):
+        cc = poly.ConvexContainer(PolygonEditView.polygons, steps=1)
+        plot_steps = cc.plot_steps(render=False)
+        plot_steps_html = file_html(plot_steps, CDN, "my plot23")
+        # PackingPolygons.context["packed_polygons"]=plot_steps_html
+        return render(request, 'plots/index_new.html', context={"plot_steps": plot_steps_html})
+    def post(self, request, *args, **kwargs):
+        angle = int(request.POST["angle"])
+        cc = poly.ConvexContainer(PolygonEditView.polygons, steps=angle)
+        plot_steps = cc.plot_steps(render=False)
+        plot_steps_html = file_html(plot_steps, CDN, "my plot23")
+        return render(request, 'plots/index_new.html', context={"plot_steps": plot_steps_html})
 
-            polygon2 = poly.Polygon(polygon)
-            print("konkav",list(polygon2.exterior.coords))
-            polygon_parent_class = polygon2.convex_hull
-            polygon2 = poly.Polygon2(list(polygon_parent_class.exterior.coords))
-            print("convex",polygon2.shell)
-            real_polygons.append(polygon2)
-        # print(polygon_list)
-        # q = map(list, zip(*polygon_list))
-        # s=  json.loads(test)
-        # x = s["x"]
-        # y = s["y"]
-        # source = ColumnDataSource(data=dict(x=polygon_x_list, y=polygon_y_list),name='my-data-source')
-        # print(test)
-        plot = poly.plot_polygons_in_single_plot(real_polygons,render=False)
-        # plot = poly.plot_polygons(real_polygons,render=False)
-        # print(type(test))
-        # p = figure()
-        # p.multi_line("x", "y", source=source)
-        response = file_html(plot, CDN, "my plot")
 
-        # polygon = Polygon(polygon_points)
-        # polygon_parent_class = polygon.convex_hull
-        # polygon2 = Polygon2(list(polygon_parent_class.exterior.coords))
-        return HttpResponse(response)
 
 class PolygonEditView(View):
     context={}
@@ -291,15 +97,15 @@ class PolygonEditView(View):
     plot_max_x= 100
     plot_min_y = 0
     plot_max_y= 100
-    colum_data_x=[[]]
-    colum_data_y=[[]]
+    colum_data_x=[] # wil be a list of lists
+    colum_data_y=[]
     def get(self, request, *args, **kwargs):
         TOOLTIPS = [("index", "$index"), ("(x,y)", "($x{1.1}, $y{1.1})"), ]
         source = ColumnDataSource(data=dict(x=PolygonEditView.colum_data_x,
                                             y=PolygonEditView.colum_data_y),
                                   name='my-data-source')
 
-        p = figure(x_range=(PolygonEditView.plot_min_x, PolygonEditView.plot_max_x), y_range=(PolygonEditView.plot_min_y, PolygonEditView.plot_max_y), width=750, height=750,
+        p = figure(x_range=(PolygonEditView.plot_min_x, PolygonEditView.plot_max_x), y_range=(PolygonEditView.plot_min_y, PolygonEditView.plot_max_y), width=1000, height=1000,
                    title='Poly Edit Tool', tooltips=TOOLTIPS)
         p.aspect_ratio = 1
         p1 = p.patches("x", "y", fill_alpha=0.4, source=source, fill_color="red")
@@ -310,9 +116,11 @@ class PolygonEditView(View):
         edit_tool = PolyEditTool(renderers=[p1], vertex_renderer=c1)
 
         p.add_tools(draw_tool, edit_tool)
-        p.toolbar.active_drag = edit_tool
+        p.toolbar.active_drag = draw_tool
         response = file_html(p, CDN, "my plot")
-        PolygonEditView.context["response"]=response
+        PolygonEditView.context["response"] = response
+
+
         return render(request, 'plots/test.html', PolygonEditView.context)
 
     def post(self, request, *args, **kwargs):
@@ -331,7 +139,7 @@ class PolygonEditView(View):
 
 
         polygon_list=[]
-        polygons_x_y_tuple = list(zip(dict_poly["x"],dict_poly["y"]))
+        polygons_x_y_tuple = list(zip(dict_poly["x"], dict_poly["y"]))
         # polygon_x_list = []
         # polygon_y_list = []
         for x,y in  polygons_x_y_tuple:
@@ -353,27 +161,24 @@ class PolygonEditView(View):
                 polygon.append(polygon[0])
 
 
-            polygon2 = poly.Polygon(polygon)
-            print("konkav",list(polygon2.exterior.coords))
-            polygon_parent_class = polygon2.convex_hull
-            polygon2 = poly.Polygon2(list(polygon_parent_class.exterior.coords))
+            polygon2 = poly.ConvexPolygon(polygon)
+            print("konkav",list(polygon2.shell))
+            #polygon_parent_class = polygon2.convex_hull
+            #polygon2 = poly.Polygon2(list(polygon_parent_class.exterior.coords))
             polygon_max_x_list.append(polygon2.max_x)
             polygon_min_x_list.append(polygon2.min_x)
             polygon_max_y_list.append(polygon2.max_y)
             polygon_min_y_list.append(polygon2.min_y)
             real_polygons.append(polygon2)
+        # for setting the plot
         PolygonEditView.polygons = real_polygons
-
         PolygonEditView.plot_max_y = max(polygon_max_y_list)
-
         PolygonEditView.plot_min_y = min(polygon_min_y_list)
-
         PolygonEditView.plot_max_x = max(polygon_max_x_list)
-
         PolygonEditView.plot_min_x = min(polygon_min_x_list)
 
 
-        polygons_single_plot = poly.plot_polygons_in_single_plot(real_polygons,render=False)
+        polygons_single_plot = poly.plot_polygons_in_single_plot(real_polygons,plot_height=1000, plot_width=2000,render=False)
         plot = poly.plot_polygons(real_polygons,render=False)
         # print(type(test))
         # p = figure()
@@ -383,5 +188,7 @@ class PolygonEditView(View):
         #self.polygons.append(response2)
         PolygonEditView.context["polygons_plot"]= polygons_plot_html
         PolygonEditView.context["polygons_single_plot"] = polygons_single_plot_html
+
+
         return HttpResponseRedirect('/test/')
 

mysite/requirements/base.txt

-shapely==1.7.1
-matplotlib==3.3.2
-path==15.0.0
-numpy==1.19.2
-mplcursors==0.3
+django
+matplotlib
+path
+numpy
+mplcursors
 mpld3
 bokeh
 django-jquery
-django.js==0.8.1
-pandas ==1.1.3
\ No newline at end of file
+django.js
+pandas
+scipy
+ipython
+shapely
\ No newline at end of file