diff --git a/extensions/fablabchemnitz/CardLayoutGuides.py b/extensions/fablabchemnitz/CardLayoutGuides.py
index 38116ba8..361a2cce 100644
--- a/extensions/fablabchemnitz/CardLayoutGuides.py
+++ b/extensions/fablabchemnitz/CardLayoutGuides.py
@@ -454,7 +454,7 @@ class FoldedCardLayoutGuidesEffect(inkex.EffectExtension):
 
 		### GUIDES
 		# remove all the existing guides
-		[node.getparent().remove(node) for node in self.document.xpath('//sodipodi:guide',namespaces=inkex.NSS)]
+		[node.delete() for node in self.document.xpath('//sodipodi:guide',namespaces=inkex.NSS)]
 
 		# create the generator object
 		gen = LineGeneratorBase.CreateLineGenerator(opt.layout, opt.orientation, opt.card_width, opt.card_height, opt.card_margin, opt.bleed_margin, pageWidth, pageHeight, opt.page_margin, self.svg.unittouu)
@@ -463,7 +463,7 @@ class FoldedCardLayoutGuidesEffect(inkex.EffectExtension):
 
 		### FOLD LINES
 		# remove any existing 'Crop marks' layer
-		[node.getparent().remove(node) for node in self.document.xpath("//svg:g[@inkscape:label='Crop Marks']",namespaces=inkex.NSS)]
+		[node.delete() for node in self.document.xpath("//svg:g[@inkscape:label='Crop Marks']",namespaces=inkex.NSS)]
 
 		svg = self.document.xpath('//svg:svg', namespaces=inkex.NSS)[0]
 		layer = etree.SubElement(svg, inkex.addNS('g',"svg"), {})
diff --git a/extensions/fablabchemnitz/HexLayoutGuides.py b/extensions/fablabchemnitz/HexLayoutGuides.py
index 10369835..353443f5 100644
--- a/extensions/fablabchemnitz/HexLayoutGuides.py
+++ b/extensions/fablabchemnitz/HexLayoutGuides.py
@@ -435,7 +435,7 @@ class HexLayoutGuidesEffect(inkex.Effect):
 
 		### GUIDES
 		# remove all the existing guides
-		[node.getparent().remove(node) for node in self.document.xpath('//sodipodi:guide',namespaces=inkex.NSS)]
+		[node.delete() for node in self.document.xpath('//sodipodi:guide',namespaces=inkex.NSS)]
 
 		# create the object generator
 		gen = HexGeneratorBase.CreateHexGenerator(opt.HexDiameter, opt.HexMargin, opt.BleedMargin, pageWidth, pageHeight, opt.PageMargin, self.svg.unittouu)
@@ -444,7 +444,7 @@ class HexLayoutGuidesEffect(inkex.Effect):
 
 		### CROP MARKS
 		# remove any existing 'Crop marks' layer
-		[node.getparent().remove(node) for node in self.document.xpath("//svg:g[@inkscape:label='Crop Marks']",namespaces=inkex.NSS)]
+		[node.delete() for node in self.document.xpath("//svg:g[@inkscape:label='Crop Marks']",namespaces=inkex.NSS)]
 
 		svg = self.document.xpath('//svg:svg', namespaces=inkex.NSS)[0]
 		layer = etree.SubElement(svg, inkex.addNS('g',"svg"), {})
diff --git a/extensions/fablabchemnitz/RemoveDuplicateGuides.py b/extensions/fablabchemnitz/RemoveDuplicateGuides.py
index 06efe7e9..c85b0caa 100644
--- a/extensions/fablabchemnitz/RemoveDuplicateGuides.py
+++ b/extensions/fablabchemnitz/RemoveDuplicateGuides.py
@@ -124,7 +124,7 @@ class RemoveDuplicateGuidesEffect(inkex.EffectExtension):
 		# now remove all the excess guides
 		for serial in groups:
 			for guide in groups[serial][1:]: # keep the first member of group
-				guide.node.getparent().remove(guide.node)
+				guide.node.delete()
 
 if __name__ == '__main__':
 	effect = RemoveDuplicateGuidesEffect().run()
\ No newline at end of file
diff --git a/extensions/fablabchemnitz/applytransform.py b/extensions/fablabchemnitz/applytransform.py
index 10b77737..a0dcaca9 100644
--- a/extensions/fablabchemnitz/applytransform.py
+++ b/extensions/fablabchemnitz/applytransform.py
@@ -27,21 +27,21 @@ class ApplyTransform(inkex.EffectExtension):
             self.recursiveFuseTransform(self.document.getroot())
 
     @staticmethod
-    def objectToPath(node):
-        if node.tag == inkex.addNS('g', 'svg'):
-            return node
+    def objectToPath(element):
+        if element.tag == inkex.addNS('g', 'svg'):
+            return element
 
-        if node.tag == inkex.addNS('path', 'svg') or node.tag == 'path':
-            for attName in node.attrib.keys():
+        if element.tag == inkex.addNS('path', 'svg') or element.tag == 'path':
+            for attName in element.attrib.keys():
                 if ("sodipodi" in attName) or ("inkscape" in attName):
-                    del node.attrib[attName]
-            return node
+                    del element.attrib[attName]
+            return element
 
-        return node
+        return element
 
-    def scaleStrokeWidth(self, node, transf):
-        if 'style' in node.attrib:
-            style = node.attrib.get('style')
+    def scaleStrokeWidth(self, element, transf):
+        if 'style' in element.attrib:
+            style = element.attrib.get('style')
             style = dict(Style.parse_str(style))
             update = False
 
@@ -55,32 +55,32 @@ class ApplyTransform(inkex.EffectExtension):
                     pass
 
             if update:
-                node.attrib['style'] = Style(style).to_str()
+                element.attrib['style'] = Style(style).to_str()
 
-    def recursiveFuseTransform(self, node, transf=[[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]):
+    def recursiveFuseTransform(self, element, transf=[[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]]):
 
-        transf = Transform(transf) * Transform(node.get("transform", None)) #a, b, c, d = linear transformations / e, f = translations
+        transf = Transform(transf) * Transform(element.get("transform", None)) #a, b, c, d = linear transformations / e, f = translations
 
-        if 'transform' in node.attrib:
-            del node.attrib['transform']
+        if 'transform' in element.attrib:
+            del element.attrib['transform']
 
-        node = ApplyTransform.objectToPath(node)
+        element = ApplyTransform.objectToPath(element)
 
         if transf == NULL_TRANSFORM:
             # Don't do anything if there is effectively no transform applied
-            # reduces alerts for unsupported nodes
+            # reduces alerts for unsupported elements
             pass
-        elif 'd' in node.attrib:
-            d = node.get('d')
+        elif 'd' in element.attrib:
+            d = element.get('d')
             p = CubicSuperPath(d)
             p = Path(p).to_absolute().transform(transf, True)
-            node.set('d', str(Path(CubicSuperPath(p).to_path())))
+            element.set('d', str(Path(CubicSuperPath(p).to_path())))
 
-            self.scaleStrokeWidth(node, transf)
+            self.scaleStrokeWidth(element, transf)
 
-        elif node.tag in [inkex.addNS('polygon', 'svg'),
+        elif element.tag in [inkex.addNS('polygon', 'svg'),
                           inkex.addNS('polyline', 'svg')]:
-            points = node.get('points')
+            points = element.get('points')
             points = points.strip().split(' ')
             for k, p in enumerate(points):
                 if ',' in p:
@@ -91,24 +91,24 @@ class ApplyTransform(inkex.EffectExtension):
                     p = ','.join(p)
                     points[k] = p
             points = ' '.join(points)
-            node.set('points', points)
+            element.set('points', points)
 
-            self.scaleStrokeWidth(node, transf)
+            self.scaleStrokeWidth(element, transf)
 
-        elif node.tag in [inkex.addNS("ellipse", "svg"), inkex.addNS("circle", "svg")]:
+        elif element.tag in [inkex.addNS("ellipse", "svg"), inkex.addNS("circle", "svg")]:
 
             def isequal(a, b):
                 return abs(a - b) <= transf.absolute_tolerance
 
-            if node.TAG == "ellipse":
-                rx = float(node.get("rx"))
-                ry = float(node.get("ry"))
+            if element.TAG == "ellipse":
+                rx = float(element.get("rx"))
+                ry = float(element.get("ry"))
             else:
-                rx = float(node.get("r"))
+                rx = float(element.get("r"))
                 ry = rx
 
-            cx = float(node.get("cx"))
-            cy = float(node.get("cy"))
+            cx = float(element.get("cx"))
+            cy = float(element.get("cy"))
             sqxy1 = (cx - rx, cy - ry)
             sqxy2 = (cx + rx, cy - ry)
             sqxy3 = (cx + rx, cy + ry)
@@ -116,8 +116,8 @@ class ApplyTransform(inkex.EffectExtension):
             newxy2 = transf.apply_to_point(sqxy2)
             newxy3 = transf.apply_to_point(sqxy3)
 
-            node.set("cx", (newxy1[0] + newxy3[0]) / 2)
-            node.set("cy", (newxy1[1] + newxy3[1]) / 2)
+            element.set("cx", (newxy1[0] + newxy3[0]) / 2)
+            element.set("cy", (newxy1[1] + newxy3[1]) / 2)
             edgex = math.sqrt(
                 abs(newxy1[0] - newxy2[0]) ** 2 + abs(newxy1[1] - newxy2[1]) ** 2
             )
@@ -126,31 +126,32 @@ class ApplyTransform(inkex.EffectExtension):
             )
 
             if not isequal(edgex, edgey) and (
-                node.TAG == "circle"
+                element.TAG == "circle"
                 or not isequal(newxy2[0], newxy3[0])
                 or not isequal(newxy1[1], newxy2[1])
             ):
                 inkex.utils.errormsg(
                     "Warning: Shape %s (%s) is approximate only, try Object to path first for better results"
-                    % (node.TAG, node.get("id"))
+                    % (element.TAG, element.get("id"))
                 )
 
-            if node.TAG == "ellipse":
-                node.set("rx", edgex / 2)
-                node.set("ry", edgey / 2)
+            if element.TAG == "ellipse":
+                element.set("rx", edgex / 2)
+                element.set("ry", edgey / 2)
             else:
-                node.set("r", edgex / 2)
+                element.set("r", edgex / 2)
 
-        elif node.tag == inkex.addNS("use", "svg"):    
+        # this is unstable at the moment
+        elif element.tag == inkex.addNS("use", "svg"):
             href = None
             old_href_key = '{http://www.w3.org/1999/xlink}href'
             new_href_key = 'href'
-            if node.attrib.has_key(old_href_key) is True: # {http://www.w3.org/1999/xlink}href (which gets displayed as 'xlink:href') attribute is deprecated. the newer attribute is just 'href'
-                href = node.attrib.get(old_href_key)
-                #node.attrib.pop(old_href_key)
-            if node.attrib.has_key(new_href_key) is True:
-                href = node.attrib.get(new_href_key) #we might overwrite the previous deprecated xlink:href but it's okay
-                #node.attrib.pop(new_href_key)
+            if element.attrib.has_key(old_href_key) is True: # {http://www.w3.org/1999/xlink}href (which gets displayed as 'xlink:href') attribute is deprecated. the newer attribute is just 'href'
+                href = element.attrib.get(old_href_key)
+                #element.attrib.pop(old_href_key)
+            if element.attrib.has_key(new_href_key) is True:
+                href = element.attrib.get(new_href_key) #we might overwrite the previous deprecated xlink:href but it's okay
+                #element.attrib.pop(new_href_key)
 
             #get the linked object from href attribute
             linkedObject = self.document.getroot().xpath("//*[@id = '%s']" % href.lstrip('#')) #we must remove hashtag symbol
@@ -161,14 +162,14 @@ class ApplyTransform(inkex.EffectExtension):
                 mask = None #image might have an alpha channel
                 new_mask_id = self.svg.get_unique_id("mask")
                 newMask = None
-                if node.attrib.has_key('mask') is True:
-                    mask = node.attrib.get('mask')
-                    #node.attrib.pop('mask')
+                if element.attrib.has_key('mask') is True:
+                    mask = element.attrib.get('mask')
+                    #element.attrib.pop('mask')
 
                 #get the linked mask from mask attribute. We remove the old and create a new
                 if mask is not None:
                     linkedMask = self.document.getroot().xpath("//*[@id = '%s']" % mask.lstrip('url(#').rstrip(')')) #we must remove hashtag symbol
-                    linkedMask[0].getparent().remove(linkedMask[0])
+                    linkedMask[0].delete()
                     maskAttributes = {'id': new_mask_id}
                     newMask = etree.SubElement(self.document.getroot(), inkex.addNS('mask', 'svg'), maskAttributes)
             
@@ -182,25 +183,25 @@ class ApplyTransform(inkex.EffectExtension):
                     linkedObjectCopy.set('mask', 'url(#' + new_mask_id + ')')
                     maskRectAttributes = {'x': '{:1.6f}'.format(transf.e), 'y': '{:1.6f}'.format(transf.f), 'width': '{:1.6f}'.format(width), 'height': '{:1.6f}'.format(height), 'style':'fill:#ffffff;'}
                     maskRect = etree.SubElement(newMask, inkex.addNS('rect', 'svg'), maskRectAttributes)
+                self.document.getroot().append(linkedObjectCopy) #for each svg:use we append a copy to the document root
+                element.delete() #then we remove the use object
             else:
-                self.recursiveFuseTransform(linkedObjectCopy, transf)
+                #self.recursiveFuseTransform(linkedObjectCopy, transf)
+                self.recursiveFuseTransform(element.unlink(), transf)
 
-            self.document.getroot().append(linkedObjectCopy) #for each svg:use we append a copy to the document root
-            node.getparent().remove(node) #then we remove the use object
-
-        elif node.tag in [inkex.addNS('rect', 'svg'),
+        elif element.tag in [inkex.addNS('rect', 'svg'),
                           inkex.addNS('text', 'svg'),
                           inkex.addNS('image', 'svg')]:
             inkex.utils.errormsg(
                 "Shape %s (%s) not yet supported, try Object to path first"
-                % (node.TAG, node.get("id"))
+                % (element.TAG, element.get("id"))
             )
 
         else:
             # e.g. <g style="...">
-            self.scaleStrokeWidth(node, transf)
+            self.scaleStrokeWidth(element, transf)
 
-        for child in node.getchildren():
+        for child in element.getchildren():
             self.recursiveFuseTransform(child, transf)
 
 if __name__ == '__main__':
diff --git a/extensions/fablabchemnitz/chain_paths.py b/extensions/fablabchemnitz/chain_paths.py
index fcfc3b50..d8c309fd 100644
--- a/extensions/fablabchemnitz/chain_paths.py
+++ b/extensions/fablabchemnitz/chain_paths.py
@@ -260,7 +260,7 @@ class ChainPaths(inkex.EffectExtension):
       if not len(new):
         # node.clear()
         if node.getparent() is not None:
-            node.getparent().remove(node)
+            node.delete()
             obsoleted += 1
             if debug: inkex.utils.debug("Path node obsoleted: " +str(id))
       else:
diff --git a/extensions/fablabchemnitz/contourscanner/contour_scanner.py b/extensions/fablabchemnitz/contourscanner/contour_scanner.py
index 29b043d7..c90024e7 100644
--- a/extensions/fablabchemnitz/contourscanner/contour_scanner.py
+++ b/extensions/fablabchemnitz/contourscanner/contour_scanner.py
@@ -111,7 +111,7 @@ class ContourScanner(inkex.EffectExtension):
                 parent.insert(idx, replacedNode)
                 idSuffix += 1
                 self.replacedNodes.append(replacedNode)
-            parent.remove(node)
+            node.delete()
         for child in node:
             self.breakContours(child)
     
@@ -158,7 +158,7 @@ class ContourScanner(inkex.EffectExtension):
                          node.attrib['style'] = Style(style).to_str()
                     if self.options.remove_opened:
                         try:
-                            node.getparent().remove(node)
+                            node.delete()
                         except AttributeError:
                             pass #we ignore that parent can be None
                 if closed == True:
@@ -169,7 +169,7 @@ class ContourScanner(inkex.EffectExtension):
                         node.attrib['style'] = Style(style).to_str()
                     if self.options.remove_closed:
                         try:
-                            node.getparent().remove(node)
+                            node.delete()
                         except AttributeError:
                             pass #we ignore that parent can be None
  
@@ -220,7 +220,7 @@ class ContourScanner(inkex.EffectExtension):
                                     node.attrib['style'] = intersectionStyle
                                 if self.options.remove_selfintersecting:
                                     if node.getparent() is not None: #might be already been deleted by previously checked settings so check again
-                                        node.getparent().remove(node)
+                                        node.delete()
                                         
                         #draw intersections segment lines - useless at the moment. We could use this information to cut the original polyline to get a new curve path which included the intersection points
                         #isectSegs = poly_point_isect.isect_polygon_include_segments(points)
@@ -254,7 +254,7 @@ class ContourScanner(inkex.EffectExtension):
                 if len(intersectionGroup.getchildren()) == 0:
                     intersectionGroupParent = intersectionGroup.getparent()
                     if intersectionGroupParent is not None:
-                        intersectionGroup.getparent().remove(intersectionGroup)
+                        intersectionGroup.delete()
                 #put the node into the intersectionGroup to bundle the path with it's error markers. If removal is selected we need to avoid intersectionGroup.insert(), because it will break the removal
                 elif self.options.remove_selfintersecting == False:
                     intersectionGroup.insert(0, node)
diff --git a/extensions/fablabchemnitz/filletchamfer.py b/extensions/fablabchemnitz/filletchamfer.py
index 9dd230d5..261b8e1a 100644
--- a/extensions/fablabchemnitz/filletchamfer.py
+++ b/extensions/fablabchemnitz/filletchamfer.py
@@ -287,7 +287,7 @@ class FilletChamfer(inkex.EffectExtension):
                 self.addEle(inkex.addNS('path','svg'), node.getparent(), attrib)
 
         if self.options.remove:
-            node.getparent().remove(node)
+            node.delete()
 				
 if __name__ == '__main__':
     FilletChamfer().run()
\ No newline at end of file
diff --git a/extensions/fablabchemnitz/imagetracer.js/imagetracerjs.py b/extensions/fablabchemnitz/imagetracer.js/imagetracerjs.py
index c9cf5c58..8e57bcdd 100644
--- a/extensions/fablabchemnitz/imagetracer.js/imagetracerjs.py
+++ b/extensions/fablabchemnitz/imagetracer.js/imagetracerjs.py
@@ -164,7 +164,7 @@ class Imagetracerjs (inkex.EffectExtension):
                     
                     #remove the old image or not                    
                     if self.options.keeporiginal is not True:
-                        node.getparent().remove(node)                    
+                        node.delete()                 
         else:
             inkex.utils.debug("No image found for tracing. Please select an image first.")        
 
diff --git a/extensions/fablabchemnitz/lineshading/endurance_line_shading.py b/extensions/fablabchemnitz/lineshading/endurance_line_shading.py
index c9976edf..295083bd 100644
--- a/extensions/fablabchemnitz/lineshading/endurance_line_shading.py
+++ b/extensions/fablabchemnitz/lineshading/endurance_line_shading.py
@@ -24,297 +24,297 @@ from lxml import etree
 from inkex.paths import Path
 
 def saw(x):
-  #The function returns a symmetric triangle wave with period 4 and varying between -1 and 1
-  x = math.fmod(x, 4.0)
-  x = math.fabs(x)
-  if x > 2.0:
-    y = 3 - x
-  else:
-    y = x - 1    
-  return y
+    #The function returns a symmetric triangle wave with period 4 and varying between -1 and 1
+    x = math.fmod(x, 4.0)
+    x = math.fabs(x)
+    if x > 2.0:
+        y = 3 - x
+    else:
+        y = x - 1        
+    return y
  
 def square(x):
-  #The function returns a square wave with period 4 and varying between -1 and 1
-  x = math.fmod(x, 4.0)
-  if 1.0 < x < 3.0:
-    y = 1.0
-  else:
-    y = -1.0    
-  return y
+    #The function returns a square wave with period 4 and varying between -1 and 1
+    x = math.fmod(x, 4.0)
+    if 1.0 < x < 3.0:
+        y = 1.0
+    else:
+        y = -1.0        
+    return y
 
 class LineShading(inkex.Effect):
-    def __init__(self):
-        inkex.Effect.__init__(self)
-        self.arg_parser.add_argument('--palette', help='Choose the colors...')
-        self.arg_parser.add_argument("--waveform",  help="Select the shape of the curve")        
-        self.arg_parser.add_argument("--num_lines", type=int,  help="Number of lines")                          
-        self.arg_parser.add_argument("--min_period", type=float, help="Minimum period (corresponds to black pixels)")    
-        self.arg_parser.add_argument("--max_period", type=float, help="Maximum period (corresponds to white pixels)")  
-        self.arg_parser.add_argument("--min_amplitude", type=float, help="Minimum amplitude (corresponds to white pixels)")     
-        self.arg_parser.add_argument("--max_amplitude", type=float, help="Maximum amplitude (corresponds to black pixels)")   
-        self.arg_parser.add_argument("--gamma", type=float, help="Maximum amplitude (corresponds to black pixels)")                       
-        self.arg_parser.add_argument("--line_width", type=float,  help="Line width")
-        self.arg_parser.add_argument("--units", help="Units for line thickness")            
-        self.arg_parser.add_argument("--remove", type=inkex.Boolean, help="If True, source image is removed")                  
-        self.arg_parser.add_argument("--active-tab", help="The selected UI-tab when OK was pressed")
+        def __init__(self):
+                inkex.Effect.__init__(self)
+                self.arg_parser.add_argument('--palette', help='Choose the colors...')
+                self.arg_parser.add_argument("--waveform",    help="Select the shape of the curve")                
+                self.arg_parser.add_argument("--num_lines", type=int,    help="Number of lines")                                                    
+                self.arg_parser.add_argument("--min_period", type=float, help="Minimum period (corresponds to black pixels)")        
+                self.arg_parser.add_argument("--max_period", type=float, help="Maximum period (corresponds to white pixels)")    
+                self.arg_parser.add_argument("--min_amplitude", type=float, help="Minimum amplitude (corresponds to white pixels)")         
+                self.arg_parser.add_argument("--max_amplitude", type=float, help="Maximum amplitude (corresponds to black pixels)")     
+                self.arg_parser.add_argument("--gamma", type=float, help="Maximum amplitude (corresponds to black pixels)")                                             
+                self.arg_parser.add_argument("--line_width", type=float,    help="Line width")
+                self.arg_parser.add_argument("--units", help="Units for line thickness")                        
+                self.arg_parser.add_argument("--remove", type=inkex.Boolean, help="If True, source image is removed")                                    
+                self.arg_parser.add_argument("--active-tab", help="The selected UI-tab when OK was pressed")
 
-    def drawfunction(self, image_w, image_h, file):    
-      reader = png.Reader(file)
-      w, h, pixels, metadata = reader.read_flat()          
-      matrice = [[1.0 for i in range(w)]for j in range(h)] 
-      if metadata['alpha']: 
-        n = 4 
-      else: 
-        n = 3
-      #RGB convert to grayscale 0.21R + 0.72G + 0.07B    
-      for y in range(h):    
-        for x in range(w):
-           pixel_pos = (x + y * w)*n
-           p = 1.0 - (pixels[pixel_pos]*0.21 + pixels[(pixel_pos+1)]*0.72 + pixels[(pixel_pos+2)]*0.07)/255.0
-           matrice[y][x] = math.pow(p, 1.0/self.options.gamma)
-      
-      points = []
-      step_y = image_h/h
-      step_x = image_w/(w-1)
-      min_amplitude = self.options.min_amplitude*step_y/2
-      max_amplitude = self.options.max_amplitude*step_y/2
-      min_period = self.options.min_period*step_y
-      max_period = self.options.max_period*step_y
-      min_frequency = 1.0/max_period   
-      max_frequency = 1.0/min_period    
-              
-      #Sinusoidal wave (optimized)      
-      if self.options.waveform == 'sin':
-        for y in range(h):
-          pi = math.pi
-          phase = 0.0
-          coord_x = 0.0
-          amplitude = 0.0
-          n_step = 0
-          x0 = 0.0
-          y0 = math.sin(phase)*(min_amplitude + (max_amplitude - min_amplitude)*matrice[y][x]) + (y+0.5)*step_y
-          points.append(['M',[x0, y0]])
-          for x in range(w):
-            period = min_period + (max_period - min_period)*(1-matrice[y][x])
-            #period = 1.0/(min_frequency + (max_frequency - min_frequency)*(matrice[y][x]))
-            d_phase = 2.0*pi/period*step_x            
-            #calculate y
-            if phase > 2.0*pi:
-              if n_step > 0:
-                x3 = coord_x
-                y3 = -amplitude/n_step + (y+0.5)*step_y
-                x2 = x3 - (x3-x0)*0.32
-                y2 = y3
-                x1 = x0 + (x3-x0)*0.34
-                y1 = y0
-                x0 = x3
-                y0 = y3
-                points.append(['C',[x1, y1, x2, y2, x3, y3]])
-                n_step = 0
-                amplitude = 0
-            elif phase < pi < (phase + d_phase):
-              if n_step > 0:
-                x3 = coord_x
-                y3 = amplitude/n_step + (y+0.5)*step_y
-                x2 = x3 - (x3-x0)*0.34
-                y2 = y3
-                x1 = x0 + (x3-x0)*0.32
-                y1 = y0
-                x0 = x3
-                y0 = y3
-                points.append(['C',[x1, y1, x2, y2, x3, y3]])
-                n_step = 0
-                amplitude = 0
-            phase = math.fmod(phase, 2.0*pi)            
-            #calculate x
-            if phase < 0.5*pi < (phase + d_phase):
-              coord_x = (x - (phase - 0.5*pi)/d_phase)*step_x
-            elif phase < 1.5*pi < (phase + d_phase):
-              coord_x = (x - (phase - 1.5*pi)/d_phase)*step_x               
-            phase += d_phase
-            amplitude += (min_amplitude + (max_amplitude - min_amplitude)*matrice[y][x])
-            n_step += 1         
-          #add last point          
-          if n_step > 0:
-            phase = math.fmod(phase, 2.0*pi)
-            if (0 < phase < 0.5*pi) or (pi < phase < 1.5*pi):
-              x3 = (w-1)*step_x
-              y3 = amplitude*math.sin(phase)/n_step + (y+0.5)*step_y
-              x2 = x3
-              y2 = y3
-              x1 = x0 + (x3-x0)*0.33
-              y1 = y0
-              points.append(['C',[x1, y1, x2, y2, x3, y3]])
-            else:
-              if coord_x > (w-1)*step_x:
-                coord_x = (w-1)*step_x
-              x3 = coord_x
-              y3 = math.copysign( amplitude , math.sin(phase))/n_step + (y+0.5)*step_y
-              x2 = x3 - (x3-x0)*0.32
-              y2 = y3
-              x1 = x0 + (x3-x0)*0.34
-              y1 = y0
-              points.append(['C',[x1, y1, x2, y2, x3, y3]])
-              if coord_x < (w-1)*step_x:
-                x0 = x3
-                y0 = y3
-                x3 = (w-1)*step_x
-                y3 = amplitude*math.sin(phase)/n_step + (y+0.5)*step_y
-                x2 = x3
-                y2 = y3
-                x1 = x0 + (x3-x0)*0.33
-                y1 = y0
-                points.append(['C',[x1, y1, x2, y2, x3, y3]])
+        def drawfunction(self, image_w, image_h, file):        
+            reader = png.Reader(file)
+            w, h, pixels, metadata = reader.read_flat()                    
+            matrice = [[1.0 for i in range(w)]for j in range(h)] 
+            if metadata['alpha']: 
+                n = 4 
+            else: 
+                n = 3
+            #RGB convert to grayscale 0.21R + 0.72G + 0.07B        
+            for y in range(h):        
+                for x in range(w):
+                     pixel_pos = (x + y * w)*n
+                     p = 1.0 - (pixels[pixel_pos]*0.21 + pixels[(pixel_pos+1)]*0.72 + pixels[(pixel_pos+2)]*0.07)/255.0
+                     matrice[y][x] = math.pow(p, 1.0/self.options.gamma)
             
-      #Sinusoidal wave (Brute-force)      
-      elif self.options.waveform == 'sin_b': 
-        pi2 = math.pi*2.0
-        for y in range(h):          
-          phase = - pi2/4.0
-          for x in range(w):
-            period = min_period + (max_period - min_period)*(1-matrice[y][x])
-            amplitude = min_amplitude + (max_amplitude - min_amplitude)*matrice[y][x]
-            phase += pi2*step_x/period
-            phase = math.fmod(phase, pi2)
-            if x == 0:
-              points.append(['M',[x*step_x, amplitude*math.sin(phase) + (y+0.5)*step_y]])
-            else:
-              points.append(['L',[x*step_x, amplitude*math.sin(phase) + (y+0.5)*step_y]])       
-              
-      #Saw wave            
-      elif self.options.waveform == 'saw':
-        for y in range(h):          
-          phase = 0.0
-          coord_x = 0.0
-          amplitude = 0.0
-          n_step = 0.0
-          for x in range(w):
-            period = min_period + (max_period - min_period)*(1-matrice[y][x])
-            #period = 1.0/(min_frequency + (max_frequency - min_frequency)*(matrice[y][x]))
-            d_phase = 4.0/period*step_x
-            if phase > 4.0:
-              coord_x = (x - (phase - 4.0)/d_phase)*step_x
-            elif phase < 2.0 < (phase + d_phase):
-              coord_x = (x - (phase - 2.0)/d_phase)*step_x   
-            phase = math.fmod(phase, 4.0)
-            if (phase < 1.0 < (phase + d_phase)) or (phase < 3.0 < (phase + d_phase)): 
-              if n_step > 0:
-                if coord_x == 0.0:
-                  points.append(['M',[coord_x, amplitude*square(phase - 1.0)/n_step + (y+0.5)*step_y]])
-                else:
-                  points.append(['L',[coord_x, amplitude*square(phase - 1.0)/n_step + (y+0.5)*step_y]])
-                n_step = 0
-                amplitude = 0                          
-            phase += d_phase
-            n_step += 1.0
-            amplitude += (min_amplitude + (max_amplitude - min_amplitude)*matrice[y][x])
-          if n_step > 0:
-            points.append(['L',[(w-1)*step_x, amplitude*saw(phase - 1.0)/n_step + (y+0.5)*step_y]])
+            points = []
+            step_y = image_h/h
+            step_x = image_w/(w-1)
+            min_amplitude = self.options.min_amplitude*step_y/2
+            max_amplitude = self.options.max_amplitude*step_y/2
+            min_period = self.options.min_period*step_y
+            max_period = self.options.max_period*step_y
+            min_frequency = 1.0/max_period     
+            max_frequency = 1.0/min_period        
+                            
+            #Sinusoidal wave (optimized)            
+            if self.options.waveform == 'sin':
+                for y in range(h):
+                    pi = math.pi
+                    phase = 0.0
+                    coord_x = 0.0
+                    amplitude = 0.0
+                    n_step = 0
+                    x0 = 0.0
+                    y0 = math.sin(phase)*(min_amplitude + (max_amplitude - min_amplitude)*matrice[y][x]) + (y+0.5)*step_y
+                    points.append(['M',[x0, y0]])
+                    for x in range(w):
+                        period = min_period + (max_period - min_period)*(1-matrice[y][x])
+                        #period = 1.0/(min_frequency + (max_frequency - min_frequency)*(matrice[y][x]))
+                        d_phase = 2.0*pi/period*step_x                        
+                        #calculate y
+                        if phase > 2.0*pi:
+                            if n_step > 0:
+                                x3 = coord_x
+                                y3 = -amplitude/n_step + (y+0.5)*step_y
+                                x2 = x3 - (x3-x0)*0.32
+                                y2 = y3
+                                x1 = x0 + (x3-x0)*0.34
+                                y1 = y0
+                                x0 = x3
+                                y0 = y3
+                                points.append(['C',[x1, y1, x2, y2, x3, y3]])
+                                n_step = 0
+                                amplitude = 0
+                        elif phase < pi < (phase + d_phase):
+                            if n_step > 0:
+                                x3 = coord_x
+                                y3 = amplitude/n_step + (y+0.5)*step_y
+                                x2 = x3 - (x3-x0)*0.34
+                                y2 = y3
+                                x1 = x0 + (x3-x0)*0.32
+                                y1 = y0
+                                x0 = x3
+                                y0 = y3
+                                points.append(['C',[x1, y1, x2, y2, x3, y3]])
+                                n_step = 0
+                                amplitude = 0
+                        phase = math.fmod(phase, 2.0*pi)                        
+                        #calculate x
+                        if phase < 0.5*pi < (phase + d_phase):
+                            coord_x = (x - (phase - 0.5*pi)/d_phase)*step_x
+                        elif phase < 1.5*pi < (phase + d_phase):
+                            coord_x = (x - (phase - 1.5*pi)/d_phase)*step_x                             
+                        phase += d_phase
+                        amplitude += (min_amplitude + (max_amplitude - min_amplitude)*matrice[y][x])
+                        n_step += 1                 
+                    #add last point                    
+                    if n_step > 0:
+                        phase = math.fmod(phase, 2.0*pi)
+                        if (0 < phase < 0.5*pi) or (pi < phase < 1.5*pi):
+                            x3 = (w-1)*step_x
+                            y3 = amplitude*math.sin(phase)/n_step + (y+0.5)*step_y
+                            x2 = x3
+                            y2 = y3
+                            x1 = x0 + (x3-x0)*0.33
+                            y1 = y0
+                            points.append(['C',[x1, y1, x2, y2, x3, y3]])
+                        else:
+                            if coord_x > (w-1)*step_x:
+                                coord_x = (w-1)*step_x
+                            x3 = coord_x
+                            y3 = math.copysign( amplitude , math.sin(phase))/n_step + (y+0.5)*step_y
+                            x2 = x3 - (x3-x0)*0.32
+                            y2 = y3
+                            x1 = x0 + (x3-x0)*0.34
+                            y1 = y0
+                            points.append(['C',[x1, y1, x2, y2, x3, y3]])
+                            if coord_x < (w-1)*step_x:
+                                x0 = x3
+                                y0 = y3
+                                x3 = (w-1)*step_x
+                                y3 = amplitude*math.sin(phase)/n_step + (y+0.5)*step_y
+                                x2 = x3
+                                y2 = y3
+                                x1 = x0 + (x3-x0)*0.33
+                                y1 = y0
+                                points.append(['C',[x1, y1, x2, y2, x3, y3]])
+                        
+            #Sinusoidal wave (Brute-force)            
+            elif self.options.waveform == 'sin_b': 
+                pi2 = math.pi*2.0
+                for y in range(h):                    
+                    phase = - pi2/4.0
+                    for x in range(w):
+                        period = min_period + (max_period - min_period)*(1-matrice[y][x])
+                        amplitude = min_amplitude + (max_amplitude - min_amplitude)*matrice[y][x]
+                        phase += pi2*step_x/period
+                        phase = math.fmod(phase, pi2)
+                        if x == 0:
+                            points.append(['M',[x*step_x, amplitude*math.sin(phase) + (y+0.5)*step_y]])
+                        else:
+                            points.append(['L',[x*step_x, amplitude*math.sin(phase) + (y+0.5)*step_y]])             
+                            
+            #Saw wave                        
+            elif self.options.waveform == 'saw':
+                for y in range(h):                    
+                    phase = 0.0
+                    coord_x = 0.0
+                    amplitude = 0.0
+                    n_step = 0.0
+                    for x in range(w):
+                        period = min_period + (max_period - min_period)*(1-matrice[y][x])
+                        #period = 1.0/(min_frequency + (max_frequency - min_frequency)*(matrice[y][x]))
+                        d_phase = 4.0/period*step_x
+                        if phase > 4.0:
+                            coord_x = (x - (phase - 4.0)/d_phase)*step_x
+                        elif phase < 2.0 < (phase + d_phase):
+                            coord_x = (x - (phase - 2.0)/d_phase)*step_x     
+                        phase = math.fmod(phase, 4.0)
+                        if (phase < 1.0 < (phase + d_phase)) or (phase < 3.0 < (phase + d_phase)): 
+                            if n_step > 0:
+                                if coord_x == 0.0:
+                                    points.append(['M',[coord_x, amplitude*square(phase - 1.0)/n_step + (y+0.5)*step_y]])
+                                else:
+                                    points.append(['L',[coord_x, amplitude*square(phase - 1.0)/n_step + (y+0.5)*step_y]])
+                                n_step = 0
+                                amplitude = 0                                                    
+                        phase += d_phase
+                        n_step += 1.0
+                        amplitude += (min_amplitude + (max_amplitude - min_amplitude)*matrice[y][x])
+                    if n_step > 0:
+                        points.append(['L',[(w-1)*step_x, amplitude*saw(phase - 1.0)/n_step + (y+0.5)*step_y]])
 
-      #Square wave      
-      else:
-        for y in range(h):          
-          phase = 0.0
-          coord_x = 0.0
-          amplitude = 0.0
-          n_step = 0
-          for x in range(w):
-            period = min_period + (max_period - min_period)*(1-matrice[y][x])
-            #period = 1.0/(min_frequency + (max_frequency - min_frequency)*(matrice[y][x]))
-            d_phase = 4.0/period*step_x           
-            if phase > 4.0:
-              coord_x = (x - (phase - 4.0)/d_phase)*step_x
-            elif phase < 2.0 < (phase + d_phase):
-              coord_x = (x - (phase - 2.0)/d_phase)*step_x                
-            phase = math.fmod(phase, 4.0)  
-            if phase < 1.0 < (phase + d_phase): 
-              if n_step > 0:
-                if coord_x == 0.0:
-                  points.append(['M',[coord_x, amplitude/n_step + (y+0.5)*step_y]])
-                else:
-                  points.append(['L',[coord_x, -amplitude/n_step + (y+0.5)*step_y]])
-                  points.append(['L',[coord_x, amplitude/n_step + (y+0.5)*step_y]])
-                n_step = 0
-                amplitude = 0     
-            elif phase < 3.0 < (phase + d_phase): 
-              if n_step > 0:
-                if coord_x == 0.0:
-                  points.append(['M',[coord_x, -amplitude/n_step + (y+0.5)*step_y]])
-                else:
-                  points.append(['L',[coord_x, amplitude/n_step + (y+0.5)*step_y]])
-                  points.append(['L',[coord_x, -amplitude/n_step + (y+0.5)*step_y]])
-                n_step = 0
-                amplitude = 0                              
-            phase += d_phase
-            n_step += 1
-            amplitude += (min_amplitude + (max_amplitude - min_amplitude)*matrice[y][x])
-          if n_step > 0:
-            if 3.0 > phase > 1.0:
-              points.append(['L',[(w-1)*step_x, amplitude/n_step + (y+0.5)*step_y]])
+            #Square wave            
             else:
-              points.append(['L',[(w-1)*step_x, -amplitude/n_step + (y+0.5)*step_y]])
-      return points
-  
-    def draw_path(self, node, file):     
-      newpath = etree.Element(inkex.addNS('path','svg'))
-      line_width = self.options.line_width
-      units = self.options.units
-      s = {'stroke': '#000000', 'fill': 'none', 'stroke-linejoin': 'round', 'stroke-linecap': 'round', 'stroke-width': str(self.svg.unittouu(str(line_width) + units))}
-      newpath.set('style', str(inkex.Style(s)))      
-      x = node.get('x')
-      y = node.get('y')
-      t = 'translate('+ x +','+ y +')'
-      newpath.set('transform', t)
-      image_w = float(node.get('width'))
-      image_h = float(node.get('height'))          
-      newpath.set('d', str(Path(self.drawfunction(image_w, image_h, file))))
-      newpath.set('title', 'Line_Shading')
-      node.getparent().append(newpath)
-      newpath.set('x', x)
-       
-    def export_png(self, node, file):
-      image_w = float(node.get('width'))
-      image_h = float(node.get('height'))
-      min_period = self.options.min_period 
-      max_period = self.options.min_period        
-      poinnt_per_min_period = 8.0           
-      current_file = self.options.input_file
-      h_png = str(self.options.num_lines)
-      if min_period < max_period:
-        w_png = str(round(poinnt_per_min_period*image_w*float(h_png)/min_period/image_h))
-      else:
-        w_png = str(round(poinnt_per_min_period*image_w*float(h_png)/max_period/image_h))
-      id = node.get('id') 
-      cmd = "inkscape " + current_file + " --export-type=\"png\" --export-filename=" + file + " --actions=\"export-width:"+w_png+";export-height:"+h_png+";export-background:rgb(255,255,255);export-background-opacity:255;export-id:"+id+"\""
-      #inkex.errormsg(cmd)  
-      proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-      #inkex.utils.debug(cmd)
-      #inkex.utils.debug(proc.communicate())
-      #sys.exit(0)
-      #return_code = proc.wait()
-      #sys.exit(0)
-      f = proc.stdout
-      err = proc.stderr
-      f.close()
-      err.close()
-      proc.wait()
-      #inkex.errormsg(proc.stdout.read())	  
+                for y in range(h):                    
+                    phase = 0.0
+                    coord_x = 0.0
+                    amplitude = 0.0
+                    n_step = 0
+                    for x in range(w):
+                        period = min_period + (max_period - min_period)*(1-matrice[y][x])
+                        #period = 1.0/(min_frequency + (max_frequency - min_frequency)*(matrice[y][x]))
+                        d_phase = 4.0/period*step_x                     
+                        if phase > 4.0:
+                            coord_x = (x - (phase - 4.0)/d_phase)*step_x
+                        elif phase < 2.0 < (phase + d_phase):
+                            coord_x = (x - (phase - 2.0)/d_phase)*step_x                                
+                        phase = math.fmod(phase, 4.0)    
+                        if phase < 1.0 < (phase + d_phase): 
+                            if n_step > 0:
+                                if coord_x == 0.0:
+                                    points.append(['M',[coord_x, amplitude/n_step + (y+0.5)*step_y]])
+                                else:
+                                    points.append(['L',[coord_x, -amplitude/n_step + (y+0.5)*step_y]])
+                                    points.append(['L',[coord_x, amplitude/n_step + (y+0.5)*step_y]])
+                                n_step = 0
+                                amplitude = 0         
+                        elif phase < 3.0 < (phase + d_phase): 
+                            if n_step > 0:
+                                if coord_x == 0.0:
+                                    points.append(['M',[coord_x, -amplitude/n_step + (y+0.5)*step_y]])
+                                else:
+                                    points.append(['L',[coord_x, amplitude/n_step + (y+0.5)*step_y]])
+                                    points.append(['L',[coord_x, -amplitude/n_step + (y+0.5)*step_y]])
+                                n_step = 0
+                                amplitude = 0                                                            
+                        phase += d_phase
+                        n_step += 1
+                        amplitude += (min_amplitude + (max_amplitude - min_amplitude)*matrice[y][x])
+                    if n_step > 0:
+                        if 3.0 > phase > 1.0:
+                            points.append(['L',[(w-1)*step_x, amplitude/n_step + (y+0.5)*step_y]])
+                        else:
+                            points.append(['L',[(w-1)*step_x, -amplitude/n_step + (y+0.5)*step_y]])
+            return points
+    
+        def draw_path(self, node, file):         
+            newpath = etree.Element(inkex.addNS('path','svg'))
+            line_width = self.options.line_width
+            units = self.options.units
+            s = {'stroke': '#000000', 'fill': 'none', 'stroke-linejoin': 'round', 'stroke-linecap': 'round', 'stroke-width': str(self.svg.unittouu(str(line_width) + units))}
+            newpath.set('style', str(inkex.Style(s)))            
+            x = node.get('x')
+            y = node.get('y')
+            t = 'translate('+ x +','+ y +')'
+            newpath.set('transform', t)
+            image_w = float(node.get('width'))
+            image_h = float(node.get('height'))                    
+            newpath.set('d', str(Path(self.drawfunction(image_w, image_h, file))))
+            newpath.set('title', 'Line_Shading')
+            node.getparent().append(newpath)
+            newpath.set('x', x)
+             
+        def export_png(self, node, file):
+            image_w = float(node.get('width'))
+            image_h = float(node.get('height'))
+            min_period = self.options.min_period 
+            max_period = self.options.min_period                
+            poinnt_per_min_period = 8.0                     
+            current_file = self.options.input_file
+            h_png = str(self.options.num_lines)
+            if min_period < max_period:
+                w_png = str(round(poinnt_per_min_period*image_w*float(h_png)/min_period/image_h))
+            else:
+                w_png = str(round(poinnt_per_min_period*image_w*float(h_png)/max_period/image_h))
+            id = node.get('id') 
+            cmd = "inkscape " + current_file + " --export-type=\"png\" --export-filename=" + file + " --actions=\"export-width:"+w_png+";export-height:"+h_png+";export-background:rgb(255,255,255);export-background-opacity:255;export-id:"+id+"\""
+            #inkex.errormsg(cmd)    
+            proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            #inkex.utils.debug(cmd)
+            #inkex.utils.debug(proc.communicate())
+            #sys.exit(0)
+            #return_code = proc.wait()
+            #sys.exit(0)
+            f = proc.stdout
+            err = proc.stderr
+            f.close()
+            err.close()
+            proc.wait()
+            #inkex.errormsg(proc.stdout.read())	    
 	 
-    def effect(self):
-      image_selected_flag = False
-      for id, node in self.svg.selected.items():
-        if node.tag == inkex.addNS('image','svg'):
-          image_selected_flag = True
-          tmp_dir = tempfile.mkdtemp()
-          png_temp_file = os.path.join(tmp_dir, "LineShading.png")
-          self.export_png(node, png_temp_file)
-          self.draw_path(node, png_temp_file)
-          shutil.rmtree(tmp_dir)
-          if self.options.remove:
-            node.getparent().remove(node)
-          return
-      if not image_selected_flag:
-        inkex.errormsg("Please select an image")
+        def effect(self):
+            image_selected_flag = False
+            for id, node in self.svg.selected.items():
+                if node.tag == inkex.addNS('image','svg'):
+                    image_selected_flag = True
+                    tmp_dir = tempfile.mkdtemp()
+                    png_temp_file = os.path.join(tmp_dir, "LineShading.png")
+                    self.export_png(node, png_temp_file)
+                    self.draw_path(node, png_temp_file)
+                    shutil.rmtree(tmp_dir)
+                    if self.options.remove:
+                        node.delete()
+                    return
+            if not image_selected_flag:
+                inkex.errormsg("Please select an image")
 
 if __name__ == '__main__':
-    LineShading().run()
\ No newline at end of file
+        LineShading().run()
\ No newline at end of file
diff --git a/extensions/fablabchemnitz/pathops/pathops.py b/extensions/fablabchemnitz/pathops/pathops.py
index 790879f1..6e2174e4 100644
--- a/extensions/fablabchemnitz/pathops/pathops.py
+++ b/extensions/fablabchemnitz/pathops/pathops.py
@@ -287,7 +287,7 @@ class PathOps(inkex.EffectExtension):
             if not self.options.keep_top:
                 top_node = self.svg.getElementById(top_path)
                 if top_node is not None:
-                    top_node.getparent().remove(top_node)
+                    top_node.delete()
             # purge missing tagrefs (see below)
             self.update_tagrefs()
             # clean up
@@ -353,7 +353,7 @@ class PathOps(inkex.EffectExtension):
                 href = tagref.get(inkex.addNS('href', 'xlink'))[1:]
                 if self.svg.getElementById(href) is None:
                     if mode == 'purge':
-                        tagref.getparent().remove(tagref)
+                        tagref.delete()
                     elif mode == 'placeholder':
                         temp = etree.Element(inkex.addNS('path', 'svg'))
                         temp.set('id', href)
diff --git a/extensions/fablabchemnitz/primitive/primitive.py b/extensions/fablabchemnitz/primitive/primitive.py
index bb2f687d..68ddf716 100644
--- a/extensions/fablabchemnitz/primitive/primitive.py
+++ b/extensions/fablabchemnitz/primitive/primitive.py
@@ -151,7 +151,7 @@ class Primitive (inkex.EffectExtension):
                         exit(1)
                     #remove the old image or not                    
                     if self.options.keeporiginal is not True:
-                        node.getparent().remove(node)  
+                        node.delete()
 
                     # create clip path to remove the stuffy surroundings
                     if self.options.cliprect:
diff --git a/extensions/fablabchemnitz/shapes/shapes.py b/extensions/fablabchemnitz/shapes/shapes.py
index 299faf5d..19894eb7 100644
--- a/extensions/fablabchemnitz/shapes/shapes.py
+++ b/extensions/fablabchemnitz/shapes/shapes.py
@@ -260,7 +260,7 @@ class Shapes(inkex.Effect):
 				if midtype=="pillowrombus":
 					self.pillows(midtype, a, node, l, t, r, b, cX, cY)
 					pnts  = []
-					if deleteorigin: node.getparent().remove(node)
+					if deleteorigin: node.delete()
 
 			if (sub_bb=='chamfer'):
 				if chtype=="chamfer":
@@ -300,7 +300,7 @@ class Shapes(inkex.Effect):
 					self.pillows(chtype, a, node, l, t, r, b, cX, cY)
 					pnts  = []
 					dS = "M %sZ"
-					if deleteorigin: node.getparent().remove(node)
+					if deleteorigin: node.delete()
 				if chtype == "spiralrect":
 					An, Al = (an, al)
 					pnts = [[l,t], [An,0], [0,Al], [-An,0], [0,-Al+a]]
@@ -380,7 +380,7 @@ class Shapes(inkex.Effect):
 								nn = svgCircle(node.getparent(), rad, px, py)
 								self.estilo(nn,node)
 								pnts=[]
-								if deleteorigin: node.getparent().remove(node)
+								if deleteorigin: node.delete()
 		if sh=='nodes':
 			# get verts
 			obj, posh, posv, objS, oY =(sO.obj, int(sO.posh), int(sO.posv), sO.objsize, sO.ordery)
@@ -450,7 +450,7 @@ class Shapes(inkex.Effect):
 					orderY.sort(key=myFunc)
 					for item in orderY:
 						grp.append( item[1])
-			if deleteorigin: node.getparent().remove(node)
+			if deleteorigin: node.delete()
 			# ##############################3
 
 		d = ""
@@ -460,7 +460,7 @@ class Shapes(inkex.Effect):
 				d += "%s%s,%s " % (ss, str(n[0]),str(n[1]))
 			nn = self.addEle('path',pp, {'d':dS % (d)})
 			self.estilo(nn,node)
-			if deleteorigin: node.getparent().remove(node)
+			if deleteorigin: node.delete()
 
 	def makeRel(self,arr):
 		b = arr[:]
@@ -608,7 +608,7 @@ class Shapes(inkex.Effect):
 					# curva1
 					nn = self.addEle('path',pp,{'d':"M %sZ" % (sCurva1),'style':'stroke-width:0.02;fill:#cc0000;stroke:#000000;'})
 					self.estilo(nn,node)
-				if deleteorigin: node.getparent().remove(node)
+				if deleteorigin: node.delete()
 
 	def drawArrow(self, sO, an, al, l, t):
 		arrowType = sO.arrowtype
diff --git a/extensions/fablabchemnitz/vpypetools/vpypetools.py b/extensions/fablabchemnitz/vpypetools/vpypetools.py
index 0b0d350d..4a7ddc3e 100644
--- a/extensions/fablabchemnitz/vpypetools/vpypetools.py
+++ b/extensions/fablabchemnitz/vpypetools/vpypetools.py
@@ -384,7 +384,7 @@ class vpypetools (inkex.EffectExtension):
                 trajectoriesLayer[0].attrib.pop('fill') # remove unneccesary fill attribute
         else:
             if len(trajectoriesLayer) > 0:
-                trajectoriesLayer[0].getparent().remove(trajectoriesLayer[0])
+                trajectoriesLayer[0].delete()
    
         lineLayers = import_doc.getroot().xpath("//svg:g[not(@id='pen_up_trajectories')]", namespaces=inkex.NSS) #all layer except the pen_up trajectories layer
         if self.options.use_style_of_first_element is True and self.options.input_handling == "paths" and firstElementStyle is not None:
@@ -420,7 +420,7 @@ class vpypetools (inkex.EffectExtension):
         # Remove selection objects to do a real replace with new objects from vpype document
         if self.options.keep_objects is False:
             for node in nodesToWork:
-                node.getparent().remove(node)
+                node.delete()
     
 if __name__ == '__main__':
     vpypetools().run()
\ No newline at end of file