Adapting code to merge of simple_convex_hull and code cleanup.

1 files changed, 18 insertions, 27 deletions

diff --git a/cura/Layer.py b/cura/Layer.py
index cb64d77c2d..03b96f4f3a 100644
--- a/cura/Layer.py
+++ b/cura/Layer.py
@@ -59,7 +59,7 @@ class Layer:
             result_index_offset += polygon.lineMeshElementCount()
             self._element_count += polygon.elementCount
 
-        return (result_vertex_offset,result_index_offset)
+        return (result_vertex_offset, result_index_offset)
 
     def createMesh(self):
         return self.createMeshOrJumps(True)
@@ -68,56 +68,47 @@ class Layer:
         return self.createMeshOrJumps(False)
 
     def createMeshOrJumps(self, make_mesh):
-        builder = MeshBuilder() # This is never really used, only the mesh_data inside
-        index_pattern = numpy.array([[0,3,2,0,1,3]],dtype = numpy.int32 )
+        builder = MeshBuilder()
+        index_pattern = numpy.array([[0, 3, 2, 0, 1, 3]], dtype = numpy.int32 )
         
         line_count = 0
         if make_mesh:
             for polygon in self._polygons:
-                line_count += polygon._mesh_line_count
+                line_count += polygon.meshLineCount
         else:
             for polygon in self._polygons:
-                line_count += polygon._jump_count
+                line_count += polygon.jumpCount
             
         
         # Reserve the neccesary space for the data upfront
-        builder.reserveFaceAndVerticeCount( 2*line_count, 4*line_count )
+        builder.reserveFaceAndVertexCount(2 * line_count, 4 * line_count)
         
         for polygon in self._polygons:
-            #if make_mesh and (polygon.type == LayerPolygon.MoveCombingType or polygon.type == LayerPolygon.MoveRetractionType):
-            #    continue
-            #if not make_mesh and not (polygon.type == LayerPolygon.MoveCombingType or polygon.type == LayerPolygon.MoveRetractionType):
-            #    continue
-            
-            index_mask = numpy.logical_not(polygon._jump_mask) if make_mesh else polygon._jump_mask
+            # Filter out the types of lines we are not interesed in depending on whether we are drawing the mesh or the jumps.
+            index_mask = numpy.logical_not(polygon.jumpMask) if make_mesh else polygon.jumpMask
 
-            # Create an array with rows [p p+1] and only save those we whant to draw based on make_mesh
-            points = numpy.concatenate((polygon.data[:-1],polygon.data[1:]),1)[index_mask.ravel()]
+            # Create an array with rows [p p+1] and only keep those we whant to draw based on make_mesh
+            points = numpy.concatenate((polygon.data[:-1], polygon.data[1:]), 1)[index_mask.ravel()]
             # Line types of the points we want to draw
-            line_types = polygon._types[index_mask]
+            line_types = polygon.types[index_mask]
             
-          
-            #if polygon.type == LayerPolygon.InfillType or polygon.type == LayerPolygon.SkinType or polygon.type == LayerPolygon.SupportInfillType:
-            #    points[:,1] -= 0.01
-            #if polygon.type == LayerPolygon.MoveCombingType or polygon.type == LayerPolygon.MoveRetractionType:
-            #    points[:,1] += 0.01
-            # Shift the z-axis according to previous implementation. 
+             # Shift the z-axis according to previous implementation. 
             if make_mesh:
-                points[polygon._orInfillSkin[line_types],1::3] -= 0.01
+                points[polygon.isInfillOrSkinType(line_types), 1::3] -= 0.01
             else:
-                points[:,1::3] += 0.01
+                points[:, 1::3] += 0.01
 
             # Create an array with normals and tile 2 copies to match size of points variable
-            normals = numpy.tile( polygon.getNormals()[index_mask.ravel()], (1,2))
+            normals = numpy.tile( polygon.getNormals()[index_mask.ravel()], (1, 2))
 
             # Scale all normals by the line width of the current line so we can easily offset.
             normals *= (polygon.lineWidths[index_mask.ravel()] / 2)
 
             # Create 4 points to draw each line segment, points +- normals results in 2 points each. Reshape to one point per line
-            f_points = numpy.concatenate((points-normals,points+normals),1).reshape((-1,3))
+            f_points = numpy.concatenate((points-normals, points+normals), 1).reshape((-1, 3))
             # index_pattern defines which points to use to draw the two faces for each lines egment, the following linesegment is offset by 4 
-            f_indices = ( index_pattern + numpy.arange(0,4*len(normals),4,dtype=numpy.int32).reshape((-1,1)) ).reshape((-1,3))
-            f_colors = numpy.repeat(polygon._color_map[line_types], 4, 0)
+            f_indices = ( index_pattern + numpy.arange(0, 4 * len(normals), 4, dtype=numpy.int32).reshape((-1, 1)) ).reshape((-1, 3))
+            f_colors = numpy.repeat(polygon.mapLineTypeToColor(line_types), 4, 0)
 
             builder.addFacesWithColor(f_points, f_indices, f_colors)