output lines in glider_2d.ods

openglider/airfoil/profile_2d.py

@@ -146,8 +146,8 @@ def export_dat(self, pfad):
         with open(pfad, "w") as out:
             if self.name:
                 out.write(str(self.name))
-            for i in self.data:
-                out.write("\n" + str(i[0]) + "\t" + str(i[1]))
+            for p in self.data:
+                out.write("\n{:.12f}\t{:.12}".format(*p))
         return pfad
 
     @classmethod

openglider/glider/glider.py

@@ -260,15 +260,12 @@ def arc(self):
 
     @property
     def ribs(self):
-        if not self.cells:
-            return []
-        else:
-            ribs = []
-            for cell in self.cells:
-                for rib in cell.ribs:
-                    if rib not in ribs:
-                        ribs.append(rib)
-            return ribs
+        ribs = []
+        for cell in self.cells:
+            for rib in cell.ribs:
+                if rib not in ribs:
+                    ribs.append(rib)
+        return ribs
 
     @property
     def profile_numpoints(self):
@@ -350,10 +347,10 @@ def get_spanwise(self, x=None):
         """
         Return a list of points for a x_value
         """
-        if x is not None:
-            return [rib.align([x, 0, 0]) for rib in self.ribs]
-        else:
+        if x == 0:
             return [rib.pos for rib in self.ribs]  # This is much faster
+        else:
+            return [rib.align([x, 0, 0]) for rib in self.ribs]
 
     @property
     def attachment_points(self):

openglider/glider/parametric/export_ods.py

@@ -22,6 +22,10 @@ def export_ods_2d(glider, filename):
     doc.sheets.append(get_cell_sheet(glider))
     doc.sheets.append(get_rib_sheet(glider))
     doc.sheets.append(get_airfoil_sheet(glider))
+    doc.sheets.append(get_ballooning_sheet(glider))
+    doc.sheets.append(get_parametric_sheet(glider))
+    doc.sheets.append(get_lines_sheet(glider))
+    #doc.sheets.append(get_data_sheet(glider))
 
     # airfoil sheet
 
@@ -33,7 +37,7 @@ def export_ods_2d(glider, filename):
 def get_airfoil_sheet(glider_2d):
     profiles = glider_2d.profiles
     max_length = max(len(p) for p in profiles)
-    sheet = ezodf.Sheet(name="airfoils", size=(max_length+1, len(profiles)*2))
+    sheet = ezodf.Sheet(name="Airfoils", size=(max_length+1, len(profiles)*2))
 
     for i, profile in enumerate(profiles):
         sheet[0, 2*i].set_value(profile.name or "unnamed")
@@ -197,16 +201,82 @@ def get_rib_sheet(glider_2d):
     rigidfoils = glider_2d.elements.get("rigidfoils", [])
     rigidfoils.sort(key=lambda r: r["start"])
     for rigidfoil in rigidfoils:
+        sheet.append_columns(3)
         sheet[0, column].set_value("RIGIDFOIL")
         for rib_no in rigidfoil["ribs"]:
             sheet[rib_no+1, column].set_value(rigidfoil["start"])
-            sheet[rib_no+1, column].set_value(rigidfoil["end"])
-            sheet[rib_no+1, column].set_value(rigidfoil["distance"])
+            sheet[rib_no+1, column+1].set_value(rigidfoil["end"])
+            sheet[rib_no+1, column+1].set_value(rigidfoil["distance"])
         column += 3
 
     return sheet
 
 
+def get_ballooning_sheet(glider_2d):
+    balloonings = glider_2d.balloonings
+    line_no = max([len(b.upper_spline.controlpoints)+len(b.lower_spline.controlpoints) for b in balloonings])+1
+    sheet = ezodf.Sheet(name="Balloonings", size=(line_no, 2*len(balloonings)))
+
+    for ballooning_no, ballooning in enumerate(balloonings):
+        #sheet.append_columns(2)
+        sheet[0, 2*ballooning_no].set_value("ballooning_{}".format(ballooning_no))
+        pts = list(ballooning.upper_spline.controlpoints) + list(ballooning.lower_spline.controlpoints)
+        for i, point in enumerate(pts):
+            sheet[i+1, 2*ballooning_no].set_value(point[0])
+            sheet[i+1, 2*ballooning_no+1].set_value(point[0])
+
+    return sheet
+
+
+def get_parametric_sheet(glider):
+    line_no = 1 + max([
+        glider.shape.front_curve.numpoints,
+        glider.shape.back_curve.numpoints,
+        glider.shape.rib_distribution.numpoints,
+        glider.arc.curve.numpoints
+        ])
+    sheet = ezodf.Sheet(name="Parametric", size=(line_no, 8))
+
+    def add_curve(name, curve, column_no):
+        #sheet.append_columns(2)
+        sheet[0, column_no].set_value(name)
+        for i, p in enumerate(curve):
+            sheet[i+1, column_no].set_value(p[0])
+            sheet[i+1, column_no+1].set_value(p[1])
+
+    add_curve("front", glider.shape.front_curve.controlpoints, 0)
+    add_curve("back", glider.shape.back_curve.controlpoints, 2)
+    add_curve("rib_distribution", glider.shape.rib_distribution.controlpoints, 4)
+    add_curve("arc", glider.arc.curve.controlpoints, 6)
+
+    return sheet
+
+
+def get_lines_sheet(glider, places=3):
+    line_tree = glider.lineset.create_tree()
+    ods_sheet = ezodf.Table(name="Lines", size=(500, 500))
+
+    def insert_block(line, upper, row, column):
+        ods_sheet[row, column+1].set_value(line.line_type.name)
+        if upper:
+            ods_sheet[row, column].set_value(line.target_length)
+            for line, line_upper in upper:
+                row = insert_block(line, line_upper, row, column+2)
+        else:  # Insert a top node
+            name = line.upper_node.name
+            if not name:
+                name = "Rib_{}/{}".format(line.upper_node.rib_no,
+                                          line.upper_node.rib_pos)
+            ods_sheet[row, column].set_value(name)
+            row += 1
+        return row
+
+    row = 1
+    for line, upper in line_tree:
+        row = insert_block(line, upper, row, 1)
+
+    return ods_sheet
+
 # for i, value in enumerate(("Ribs", "Chord", "x: (m)", "y LE (m)", "kruemmung", "aoa", "Z-rotation",
 #                      "Y-Rotation-Offset", "merge", "balooning")):
 #         geom_page.get_cell((0, i)).value = value

openglider/glider/parametric/lines.py

@@ -118,6 +118,13 @@ def get_upper_nodes(self, rib_no=None):
         return list(nodes)
 
     def return_lineset(self, glider, v_inf):
+        """
+        Get Lineset_3d
+        :param glider: Glider3D
+        :param v_inf:
+        :return: LineSet (3d)
+        """
+        #v_inf = v_inf or glider.v_inf
         lines = []
         # first get the lowest points (lw-att)
         lowest = [node for node in self.nodes if isinstance(node, LowerNode2D)]
@@ -126,12 +133,12 @@ def return_lineset(self, glider, v_inf):
         for node in lowest:
             self.sort_lines(node)
         self.delete_not_connected(glider)
-        for node in self.nodes:
-            node.temp_node = node.get_node(glider)  # store the nodes to remember them with the lines
+
+        nodes_3d = {node: node.get_node(glider) for node in self.nodes}
         # set up the lines!
         for line_no, line in enumerate(self.lines):
-            lower = line.lower_node.temp_node
-            upper = line.upper_node.temp_node
+            lower = nodes_3d[line.lower_node]
+            upper = nodes_3d[line.upper_node]
             if lower and upper:
                 line = Line(number=line_no, lower_node=lower, upper_node=upper,
                             vinf=v_inf, target_length=line.target_length,
@@ -163,6 +170,35 @@ def sort_lines(self, lower_att):
                     line.is_sorted = True
                     self.sort_lines(line.upper_node)
 
+    def get_upper_connected_lines(self, node):
+        return [line for line in self.lines if line.lower_node is node]
+
+    def create_tree(self, start_node=None):
+        """
+        Create a tree of lines
+        :return: [{name: "", length: 0, upper: []},]
+        """
+        if start_node is None:
+            start_node = [node for node in self.nodes if isinstance(node, LowerNode2D)]
+            lines = []
+            for node in start_node:
+                lines += self.get_upper_connected_lines(node)
+        else:
+            lines = self.get_upper_connected_lines(start_node)
+
+        def get_influence_nodes(line):
+            if isinstance(line.upper_node, UpperNode2D):
+                return [line.upper_node]
+            return sum([get_influence_nodes(l) for l in self.get_upper_connected_lines(line.upper_node)],[])
+
+        def sort_key(line):
+            nodes = get_influence_nodes(line)
+            return sum([100*node.rib_no+node.rib_pos for node in nodes])/len(nodes)
+
+        lines.sort(key=sort_key)
+
+        return [[line, self.create_tree(line.upper_node)] for line in lines]
+
     def delete_not_connected(self, glider):
         temp = []
         temp_new = []

openglider/lines/lineset.py

@@ -201,6 +201,27 @@ def total_length(self):
             length += line.get_stretched_length()
         return length
 
+    def create_tree(self, start_node=None):
+        """
+        Create a tree of lines
+        :return: [{name: "", length: 0, upper: []},]
+        """
+        if start_node is None:
+            start_node = self.lower_attachment_points
+            lines = []
+            for node in start_node:
+                lines += self.get_upper_connected_lines(node)
+        else:
+            lines = self.get_upper_connected_lines(start_node)
+
+        def sort_key(line):
+            nodes = self.get_upper_influence_nodes(line)
+            return sum([100*node.vec[1]+node.vec[0] for node in nodes])/len(nodes)
+
+        lines.sort(key=sort_key)
+
+        return [[line, self.create_tree(line.upper_node)] for line in lines]
+
     def copy(self):
         return copy.deepcopy(self)
 

openglider/plots/spreadsheets/lines.py

@@ -38,15 +38,16 @@ def sort_key(line):
 
 
 def output_lines(glider, ods_sheet=None, places=3):
-    line_tree = create_line_tree(glider)
+    #line_tree = create_line_tree(glider)
+    line_tree = glider.lineset.create_tree()
     ods_sheet = ods_sheet or ezodf.Table(name="lines", size=(500, 500))
 
     def insert_block(line, upper, row, column):
         length = round(line.get_stretched_length(), places)
         ods_sheet[row, column].set_value(length)
         ods_sheet[row, column+1].set_value(line.type.name)
         if upper:
-            for line, line_upper in upper.items():
+            for line, line_upper in upper:
                 row = insert_block(line, line_upper, row, column+2)
         else:  # Insert a top node
             name = line.upper_node.name
@@ -58,7 +59,7 @@ def insert_block(line, upper, row, column):
         return row
 
     row = 1
-    for line, upper in line_tree.items():
+    for line, upper in line_tree:
         row = insert_block(line, upper, row, 1)
 
     return ods_sheet

openglider/vector/polyline.py

@@ -15,7 +15,7 @@ def __getitem__(self, ik):
         elif isinstance(ik, slice):  # example: list[1.2:5.5:1]
             values = self.get_positions(ik.start, ik.stop, ik.step)
             #print(values, ik.start, ik.stop, ik.step, step, start_round, stop_round)
-            return self.__class__([self[i] for i in values])
+            return PolyLine([self[i] for i in values])
         else:
             if ik < 0:
                 k = ik
@@ -147,6 +147,13 @@ def __add__(self, other):  # this is python default behaviour for lists
         else:
             raise ValueError("cannot append: ", self.__class__, other.__class__)
 
+    def __getitem__(self, ik):
+        res = super(PolyLine2D, self).__getitem__(ik)
+        if isinstance(ik, slice):
+            return PolyLine2D(res.data)
+        return res
+
+
     def new_cut(self, p1, p2, startpoint=0, extrapolate=False, cut_only_positive=False):
         """
         Iterate over all cuts with the line p1p2
@@ -260,10 +267,12 @@ def mirror(self, p1, p2):
 
         return self
 
-    def rotate(self, angle, startpoint=None):
+    def rotate(self, angle, startpoint=None, radians=True):
         """
         Rotate counter-clockwise around a (non)given startpoint [rad]
         """
+        if not radians:
+            angle = numpy.pi*angle/180
         rotation_matrix = rotation_2d(angle)
         new_data = []
         for point in self.data:
@@ -290,9 +299,14 @@ def _repr_svg_(self):
         height = bbox[1][1] - bbox[0][1]
 
         import svgwrite
+        import svgwrite.container
         drawing = svgwrite.Drawing(size=[800, 800*height/width])
 
-        drawing.viewbox(bbox[0][0]-border*width, bbox[0][1]-border*height, width*(1+2*border), height*(1+2*border))
-        drawing.add(drawing.polyline(self.data, style="stroke:black; vector-effect: non-scaling-stroke; fill: none;"))
+        drawing.viewbox(bbox[0][0]-border*width, -bbox[1][1]-border*height, width*(1+2*border), height*(1+2*border))
+        g = svgwrite.container.Group()
+        g.scale(1, -1)
+        line = drawing.polyline(self.data, style="stroke:black; vector-effect: non-scaling-stroke; fill: none;")
+        g.add(line)
+        drawing.add(g)
 
         return drawing.tostring()