femagtools 1.3.0__py3-none-any.whl → 1.3.2__py3-none-any.whl

femagtools/dxfsl/geom.py

@@ -276,6 +276,32 @@ def lw_polyline(entity, lf, xoff=0.0, yoff=0.0, rotation=0.0):
                    xoff=xoff, yoff=yoff,
                    rotation=rotation)
 
+def ellipse(entity, lf, xoff=0.0, yoff=0.0, rotation=0.0):
+    w = np.linalg.norm(entity.major_axis) * 2
+    h = entity.ratio * w
+    theta = np.arctan2(entity.major_axis[1], entity.major_axis[0])
+    start_angle = entity.start_param
+    end_angle = entity.end_param
+    if end_angle < start_angle:
+        end_angle += 2*np.pi
+    alfa = np.linspace(start_angle, end_angle, 20)
+    x = 0.5 * w * np.cos(alfa)
+    y = 0.5 * h * np.sin(alfa)
+    R = np.array([
+        [np.cos(theta), -np.sin(theta)],
+        [np.sin(theta),  np.cos(theta)]
+    ])
+    x, y = np.dot(R, [x, y])
+    x += entity.center[0]
+    y += entity.center[1]
+    points = np.array((x,y)).T
+    p1 = points[0]
+    for p2 in points[1:]:
+        yield Line(Element(start=p1, end=p2), lf,
+                   xoff=xoff, yoff=yoff,
+                   rotation=rotation)
+        p1 = p2
+
 
 def spline(entity, lf, min_dist=0.001, xoff=0.0, yoff=0.0, rotation=0.0):
     if False:
@@ -493,22 +519,26 @@ def dxfshapes(dxffile, mindist=0.01, layers=[]):
                 for l in insert_block(dwg, e, lf, rf, block, min_dist=mindist):
                     yield l
             elif e.dxftype == 'ELLIPSE':
-                w = np.linalg.norm(e.major_axis) * 2
-                h = e.ratio * w
-                rtheta = np.arctan2(e.major_axis[1], e.major_axis[0])
-                angle = rtheta*180/np.pi
-                start_angle = e.start_param*180/np.pi + angle
-                end_angle = e.end_param*180/np.pi + angle
-                arc = Arc(Element(center=e.center,
-                                  radius=w/2,
-                                  start_angle=start_angle,
-                                  end_angle=end_angle,
-                                  width=w,
-                                  height=h,
-                                  rtheta=rtheta,
-                                  start_param=e.start_param,
-                                  end_param=e.end_param))
-                yield arc
+                for l in ellipse(e, lf):
+                    yield l
+                #w = np.linalg.norm(e.major_axis) * 2
+                #h = e.ratio * w
+                #rtheta = np.arctan2(e.major_axis[1], e.major_axis[0])
+                #angle = rtheta*180/np.pi
+                #start_angle = e.start_param*180/np.pi + angle
+                #end_angle = e.end_param*180/np.pi + angle
+                #if end_angle < start_angle:
+                #    end_angle += 360
+                #arc = Arc(Element(center=e.center,
+                #                  radius=w/2,
+                #                  start_angle=start_angle,
+                #                  end_angle=end_angle,
+                #                  width=w,
+                #                  height=h,
+                #                  rtheta=rtheta,
+                #                  start_param=e.start_param,
+                #                  end_param=e.end_param))
+                #yield arc
 
             elif e.dxftype == 'POINT':
                 logger.debug("Id %d4: type %s ignored", id, e.dxftype)
@@ -817,6 +847,46 @@ class Geometry(object):
                    for n, r in zip(self.g.nodes(), rotnodes)}
         nx.relabel_nodes(self.g, mapping, copy=False)
 
+    def check_geom(self, what):
+        logger.debug("check geometry of %s", what)
+        parts = int(round(np.pi * 2 / self.alfa, 1))
+        logger.debug(" --parts......: %s", parts)
+        logger.debug(" --ist alpha..: %s", self.alfa)
+        real_alfa = np.pi * 2 / parts
+        logger.debug(" --soll alpha.: %s", real_alfa)
+        if not np.isclose(self.alfa, real_alfa):
+            logger.debug(" --BAD angle ==> get corrected machine")
+            return self.correct_geom(real_alfa)
+        return None
+
+    def correct_geom(self, correct_alpha):
+        elements = []
+        for e in self.g.edges(data=True):
+            o = e[2]['object'].correct(self.alfa, correct_alpha, ndec)
+            elements.append(o)
+        geom = Geometry(elements, self.rtol, self.atol)
+        geom.center = self.center
+        geom.alfa = correct_alpha
+        geom.min_radius = self.min_radius
+        geom.max_radius = self.max_radius
+        geom.is_inner = self.is_inner
+        geom.kind = self.kind
+        geom.sym_part = self.sym_part
+        return geom
+
+    def log_geom(self):
+        logger.info("Kind............: %s", self.kind)
+        logger.info("Center..........: %s", self.center)
+        logger.info("Alpha...........: %s", self.alfa)
+        logger.info("Is Inner........: %s", self.is_inner)
+        logger.info("Is Outer........: %s", self.is_outer)
+        logger.info("Min Radius......: %s", self.min_radius)
+        logger.info("Max Radius......: %s", self.max_radius)
+        logger.info("Mirror Corners..: %s", self.mirror_corners)
+        logger.info("Start Corners...: %s", self.start_corners)
+        logger.info("End Corners.....: %s", self.end_corners)
+        logger.info("Edges...........: %s", self.num_edges)
+
     def scale(self, factor):
         """scales all objects"""
         for e in self.g.edges(data=True):
@@ -951,15 +1021,31 @@ class Geometry(object):
         for e in edges:
             self.remove_edge(e)
 
-    def add_line(self, n1, n2):
-        line = Line(Element(start=n1, end=n2))
+    def add_line(self, n1, n2, color=None):
+        line = Line(Element(start=n1, end=n2), color=color)
         add_or_join(self,
-                    line.node1(ndec),
-                    line.node2(ndec),
+                    n1,
+                    n2,
                     line,
                     self.rtol,
                     self.atol)
 
+    def add_arc(self, n1, n2, center, radius, color=None):
+        angle_n1 = alpha_line(center, n1)
+        angle_n2 = alpha_line(center, n2)
+        arc = Arc(Element(center=center,
+                          radius=radius,
+                          start_angle=angle_n1*180/np.pi,
+                          end_angle=angle_n2*180/np.pi),
+                  color=color)
+        add_or_join(self,
+                    n1,
+                    n2,
+                    arc,
+                    self.rtol,
+                    self.atol)
+
+
     def elements(self, type):
         """return lists of objects"""
         return [e[2]['object'] for e in self.g.edges(data=True)
@@ -1077,6 +1163,36 @@ class Geometry(object):
         logger.debug("end of dist_end_min_corner: %s", d)
         return d
 
+    def get_start_airgap_corner(self):
+        if self.is_inner:
+            p = (self.max_radius, 0.0)
+            cp = self.start_corners[-1]
+        else:
+            p = (self.min_radius, 0.0)
+            cp = self.start_corners[0]
+        if points_are_close(p, cp, atol=0.5):
+            return cp, True
+        return p, False
+
+    def get_end_airgap_corner(self):
+        if self.is_inner:
+            p = point(self.center, self.max_radius, self.alfa, ndec)
+            cp = self.end_corners[-1]
+        else:
+            p = point(self.center, self.min_radius, self.alfa, ndec)
+            cp = self.end_corners[0]
+        if points_are_close(p, cp, atol=0.5):
+            return cp, True
+        return p, False
+
+    def get_start_airgap_corner_point(self):
+        p, b = self.get_start_airgap_corner()
+        return Point(p)
+
+    def get_end_airgap_corner_point(self):
+        p, b = self.get_end_airgap_corner()
+        return Point(p)
+
     def area_size(self):
         pts = [p for p in self.start_corners]
         end_pts = [p for p in reversed(self.end_corners)]
@@ -1357,7 +1473,7 @@ class Geometry(object):
 
         for n_angle, n_c, n_info_next in nbrs[1:]:
             n_info_next['angle'] = n_angle
-            if np.isclose(f_angle, n_angle):
+            if np.isclose(f_angle, n_angle, 0.01, 0.01):
                 logger.debug("   SAME DIRECTION")
                 # ACHTUNG
                 if self.is_lefthand_edge(alpha, f_info_next, n_info_next):
@@ -1401,7 +1517,7 @@ class Geometry(object):
                 'alpha_n1': alpha_n1,
                 'alpha_n2': e.get_alpha(n2),
                 'alpha_start': normalise_angle(alpha_n1 + np.pi),
-                'tracked': e_dict[x],
+                'tracked': e_dict.get(x, False),
                 'reverse': False}
         return info
 
@@ -1427,9 +1543,9 @@ class Geometry(object):
         logger.debug('   node2 = %s', info['n2'])
         logger.debug('   x     = %s', info['x'])
         logger.debug('   lock  = (%s, %s, %s)',
-                     info['data'][0],
-                     info['data'][1],
-                     info['data'][2])
+                     info['data'].get(0, False),
+                     info['data'].get(1, False),
+                     info['data'].get(2, False))
 
     def set_edge_tracked(self, info):
         x = info['x']
@@ -1540,6 +1656,16 @@ class Geometry(object):
         result['ok'] = True
         return result
 
+    def set_edge_attributes(self):
+        if nxversion == 1:
+            nx.set_edge_attributes(self.g, 0, True)
+            nx.set_edge_attributes(self.g, 1, False)
+            nx.set_edge_attributes(self.g, 2, False)
+        else:
+            nx.set_edge_attributes(self.g, True, 0)
+            nx.set_edge_attributes(self.g, False, 1)
+            nx.set_edge_attributes(self.g, False, 2)
+
     def create_list_of_areas(self, crunch=False):
         """ return list of areas for each node and their neighbors
         """
@@ -1554,15 +1680,7 @@ class Geometry(object):
             area_list.append(a)
 
         logger.debug("create new area list")
-
-        if nxversion == 1:
-            nx.set_edge_attributes(self.g, 0, True)
-            nx.set_edge_attributes(self.g, 1, False)
-            nx.set_edge_attributes(self.g, 2, False)
-        else:
-            nx.set_edge_attributes(self.g, True, 0)
-            nx.set_edge_attributes(self.g, False, 1)
-            nx.set_edge_attributes(self.g, False, 2)
+        self.set_edge_attributes()
 
         crunched = 0
         for n in self.g.nodes():
@@ -2081,11 +2199,20 @@ class Geometry(object):
             return self.alfa
 
     def __str__(self):
+        real_alfa = 0
+        if self.sym_part > 0:
+            if self.is_mirrored():
+                real_alfa = np.pi / self.sym_part
+            else:
+                real_alfa = 2*np.pi / self.sym_part
         return "name...........: {}\n".format(self._name) + \
                "kind...........: {}\n".format(self.kind) + \
                "sym_part.......: {}\n".format(self.sym_part) + \
                "sym_counterpart: {}\n".format(self.sym_counterpart) + \
                "alpha..........: {}\n".format(self.alfa) + \
+               "alpha real.....: {}\n".format(real_alfa) + \
+               "circle.........: {}\n".format(self.alfa * self.sym_part) + \
+               "mirrored.......: {}\n".format(self.is_mirrored()) + \
                "radius.........: {} -- {}\n".format(self.min_radius,
                                                     self.max_radius)
 
@@ -2550,7 +2677,7 @@ class Geometry(object):
             dist_max = max(dist_max, g[1])
         return airgaps
 
-    def detect_airgaps(self, center, startangle, endangle, atol):
+    def detect_airgaps(self, center, startangle, endangle, atol=0.1, with_end=False):
         """ Die Funktion sucht Luftspalt-Kandidaten und liefert eine Liste
             von Möglichkeiten mit jeweils einem minimalen und einem maximalen
             Radius als Begrenzung des Luftspalts.
@@ -2570,6 +2697,8 @@ class Geometry(object):
         min_radius = self.min_radius + 1.0
         cur_radius = gaplist[0][1]
         max_radius = self.max_radius - 1.0
+        if with_end:
+            max_radius = self.max_radius + 1.0
 
         for g in gaplist:
             if greater(g[0], cur_radius) and \
@@ -2930,29 +3059,59 @@ class Geometry(object):
                         shaft.type = 6  # iron shaft (Zahn)
                         return
 
+    def mark_connecting_edges(self, windings):
+        logger.debug("begin of mark_connecting_edges")
+        for a in windings:
+            logger.debug("- id of winding: %s", a.identifier())
+            for w in windings:
+                if a.id != w.id:
+                    elist = [e for e in a.list_of_equal_edges(w)]
+                    logger.debug(" --> %s equal egdes", len(elist))
+                    for e in elist:
+                        e.init_attributes('lightblue', 'no_fsl')
+
     def search_subregions(self):
         if self.is_stator():
-            return self.search_stator_subregions()
+            self.search_stator_subregions()
+        elif self.is_rotor():
+            self.search_rotor_subregions()
+        else:
+            logger.warning("no stator or rotor assigned")
+            self.search_unknown_subregions()
+        self.looking_for_corners()
 
-        if self.is_rotor():
-            return self.search_rotor_subregions()
+    def collect_windings(self):
+        found = True
+        while found:
+            windings = [a for a in self.list_of_areas()
+                        if a.type == 2]
+            bad_windings = [a for a in self.list_of_areas()
+                            if a.type == 12]
+            if not bad_windings:
+                return windings
 
-        logger.warning("no stator or rotor assigned")
-        return self.search_unknown_subregions()
+            found = False
+            for a in bad_windings:
+                if a.is_touching_areas(windings):
+                    a.type = 2
+                    found = True
+
+        return [a for a in self.list_of_areas() if a.type == 2]
 
     def search_stator_subregions(self, place=''):
-        is_inner = self.is_inner
+        logger.debug("Begin of search_stator_subregions")
+
         if place == 'in':
-            is_inner = True
+            self.is_inner = True
         elif place == 'out':
-            is_inner = False
+            self.is_inner = False
 
         if self.alfa == 0.0:
             self.alfa = np.pi * 2.0
 
         stator_size = self.area_size()
         for area in self.list_of_areas():
-            area.mark_stator_subregions(is_inner,
+            area.mark_stator_subregions(self.is_inner,
                                         stator_size,
                                         self.is_mirrored(),
                                         self.alfa,
@@ -2960,8 +3119,8 @@ class Geometry(object):
                                         self.min_radius,
                                         self.max_radius)
 
-        windings = [a for a in self.list_of_areas()
-                    if a.type == 2]
+        windings = self.collect_windings()
+        [a.set_type(0) for a in self.list_of_areas() if a.type == 12]
         windings_found = len(windings)
         logger.info("%d windings found", windings_found)
 
@@ -2970,18 +3129,23 @@ class Geometry(object):
             windings_surface.sort(reverse=True)
             max_size = windings_surface[0][0]
             for sz, w in windings_surface:
+                logger.debug("winding size = %s", sz)
                 if sz / max_size < 0.95:
                     w.set_type(0)
-
+                    if sz / max_size < 0.2:
+                        windings_found -= 1
             windings = [a for a in self.list_of_areas()
                         if a.is_winding()]
             if windings_found > 2 and len(windings) == 1:
+                logger.info("no windings remaining")
                 # no windings
                 [w.set_type(0) for w in windings]
                 [a.set_type(1) for a in self.list_of_areas() if a.is_iron()]
                 windings = []
             elif len(windings) < windings_found:
                 logger.info("%d windings remaining", len(windings))
+            if len(windings) > 2:
+                self.mark_connecting_edges(windings)
 
         wdg_min_angle = 99999
         wdg_max_angle = 0
@@ -3088,19 +3252,19 @@ class Geometry(object):
             self.check_shaft_area(shaft_areas[0])
 
     def search_rotor_subregions(self, place=''):
-        logger.debug("begin of search_rotor_subregions")
-        is_inner = self.is_inner
+        logger.debug("Begin of search_rotor_subregions")
+
         if place == 'in':
-            is_inner = True
+            self.is_inner = True
         elif place == 'out':
-            is_inner = False
+            self.is_inner = False
 
         if self.alfa == 0.0:
             self.alfa = np.pi * 2.0
 
         types = {}
         for area in self.list_of_areas():
-            t = area.mark_rotor_subregions(is_inner,
+            t = area.mark_rotor_subregions(self.is_inner,
                                            self.is_mirrored(),
                                            self.alfa,
                                            self.center,
@@ -3230,7 +3394,21 @@ class Geometry(object):
                     if a.surface < max_surface * 0.20:  # too small
                         a.set_type(0)  # air
 
-        logger.debug("begin of search_unknown_subregions")
+        logger.debug("end of search_unknown_subregions")
+
+    def looking_for_corners(self):
+        if self.is_inner:
+            logger.debug("looking_for_corners: inner")
+            start_cp = self.start_corners[-1]
+            end_cp = self.end_corners[-1]
+        else:
+            logger.debug("looking_for_corners: outer")
+            start_cp = self.start_corners[0]
+            end_cp = self.end_corners[0]
+        logger.debug("looking_for_corners: start=%s, end=%s",
+                     start_cp, end_cp)
+        for area in self.list_of_areas():
+            area.mark_airgap_corners(start_cp, end_cp)
         return
 
     def num_areas_of_type(self, type):
@@ -3483,19 +3661,16 @@ class Geometry(object):
             c += self.remove_appendix(n2, nbrs[0], incr_text + '.')
         return c
 
-    def split_and_get_intersect_points(self, center, outer_radius, angle):
+    def split_and_get_intersect_points(self, el, aktion=True):
         logger.debug("begin of split_and_get_intersect_points")
         rtol = 1e-03
         atol = 1e-03
-        line = Line(
-            Element(start=center,
-                    end=point(center, outer_radius+1, angle)))
         points = []
         for e in self.elements(Shape):
-            pts = e.intersect_line(line,
-                                   rtol=rtol,
-                                   atol=atol,
-                                   include_end=True)
+            pts = e.intersect_shape(el,
+                                    rtol=rtol,
+                                    atol=atol,
+                                    include_end=True)
             if pts:
                 pts_inside = []
                 pts_real = []
@@ -3510,7 +3685,7 @@ class Geometry(object):
                         pts_real.append(p)
                         pts_inside.append(p)
 
-                if pts_inside:
+                if pts_inside and aktion:
                     self.remove_edge(e)
                     elements = e.split(pts_inside, rtol, atol)
                     for e in elements:
@@ -3533,6 +3708,31 @@ class Geometry(object):
                         return True
         return False
 
+    def inside_area_list(self, p):
+        for area in self.list_of_areas():
+            if area.is_point_inside(p):
+                yield area
+
+    def critical_touch_point(self, points):
+        logger.debug("looking for critical touch-point")
+        winding_touched = False
+        for p in points[1:]:
+            d = distance(self.center, p)
+            logger.debug("-- p = %s, dist = %s", p, d)
+            for a in self.inside_area_list(p):
+                logger.debug("-- Area type = %s", a.type)
+                logger.debug("        min=%s,  max= %s", a.min_dist, a.max_dist)
+                logger.debug("        close to start = %s", a.close_to_startangle)
+                logger.debug("        close to end   = %s", a.close_to_endangle)
+                if a.is_winding():
+                    winding_touched = True
+                else:
+                    if winding_touched and greater(a.max_dist, d, atol=0.001):
+                        if not (a.close_to_startangle and a.close_to_endangle):
+                            logger.debug("-- return %s", p)
+                            return p
+        return None
+
     def create_lines_outside_windings(self, points):
         if not points:
             return False
@@ -3562,6 +3762,159 @@ class Geometry(object):
                 return True
         return False
 
+    def get_inner_airgap_line(self):
+        logger.debug("begin of get_inner_airgap_line")
+
+        if not self.is_inner:
+            logger.debug("end of get_inner_airgap_line: not inner")
+            return []
+        for a in self.area_list:
+            logger.debug("%s", a)
+        area = [a for a in self.area_list if a.close_to_ag_endcorner]
+        if len(area) != 1:
+            logger.debug("end of get_inner_airgap_line: %s areas found", len(area))
+            return []
+
+        end_corner = self.end_corners[-1]
+        logger.debug("END CORNER %s", end_corner)
+        nodes = [n for n in area[0].list_of_nodes()]
+        if not nodes:
+            logger.debug("end of get_inner_airgap_line: no nodes found")
+            return []
+        n1 = nodes[0]
+        if points_are_close(end_corner, n1):
+            n2 = nodes[-1]
+        else:
+            n2 = n1
+            for n1 in nodes[1:]:
+                if points_are_close(end_corner, n1):
+                    break
+                n2 = n1
+
+        if not points_are_close(end_corner, n1):
+            logger.debug("end of get_inner_airgap_line: not close to endcorner")
+            return []
+
+        start_corner = self.start_corners[-1]
+
+        logger.debug("EDGE FOUND: %s - %s", n1, n2)
+        nodes = [n1, n2]
+        info = self.get_edge_info(n1, n2)
+        while not points_are_close(start_corner, n2):
+            info = self.next_edge_lefthand_side(info)
+            if not info:
+                return []
+            n2 = info['n2']
+            nodes.append(n2)
+
+        logger.debug("end of get_inner_airgap_line #%s", len(nodes))
+        return nodes
+
+    def create_corner_areas(self):
+        self.set_edge_attributes()
+        self.create_inner_corner_areas()
+
+    def create_and_append_area(self, n1, n2):
+        rslt = self.get_new_area(n1, n2, False)
+        logger.debug("create_and_append_area: %s", rslt)
+        if rslt.get('ok', False):
+            area = rslt['area']
+            a = Area(area, self.center, 0.0)
+            a.type = 0  # air
+            self.area_list.append(a)
+            return True
+        logger.error("No area for air near airgap!!")
+        return False
+
+    def create_inner_corner_areas(self):
+        start_cp, start_exists = self.get_start_airgap_corner()
+        end_cp, end_exists = self.get_end_airgap_corner()
+        if start_exists and end_exists:
+            return
+        logger.info("*** Corner correction ***")
+        airgap_line = self.get_inner_airgap_line()
+        if not airgap_line:
+            logger.debug("no airgapline found")
+            return
+
+        logger.debug("airgapline found !!")
+        airgap_nodes = [n for n in airgap_line[1:]]
+        del airgap_nodes[-1]
+        if not airgap_nodes:
+            return  # strange
+
+        if not start_exists:
+            cp = self.start_corners[-1]
+            logger.debug("Start Corner: %s -- %s", cp, start_cp)
+            start_line = Line(Element(start=cp, end=start_cp), color='red')
+            start_cp = start_line.node2(ndec)
+            i = 0
+            for n in airgap_nodes:
+                i += 1
+                if not self.search_intersection(i, self.max_radius,
+                                                n, start_cp,
+                                                airgap_nodes):
+                    d = distance(self.center, n)
+                    if np.isclose(d, self.max_radius):
+                        self.add_arc(start_cp, n, self.center, self.max_radius, color='red')
+                    else:
+                        self.add_line(start_cp, n, color='red')
+                    self.add_edge(cp, start_cp, start_line)
+                    self.create_and_append_area(start_cp, n)
+                    self.start_corners = self.get_corner_nodes(self.center,
+                                                               0.0)
+                    break
+
+        if not end_exists:
+            cp = self.end_corners[-1]
+            logger.debug("End Corner: %s -- %s", cp, end_cp)
+            end_line = Line(Element(start=cp, end=end_cp), color='red')
+            end_cp = end_line.node2(ndec)
+            airgap_nodes.reverse()
+            i = 0
+            for n in airgap_nodes:
+                i += 1
+                if not self.search_intersection(i, self.max_radius,
+                                                n, end_cp,
+                                                airgap_nodes):
+                    d = distance(self.center, n)
+                    if np.isclose(d, self.max_radius):
+                        self.add_arc(n, end_cp, self.center, self.max_radius, color='red')
+                    else:
+                        self.add_line(end_cp, n, color='red')
+                    self.add_edge(cp, end_cp, end_line)
+                    self.create_and_append_area(n, end_cp)
+                    self.end_corners = self.get_corner_nodes(self.center,
+                                                             self.alfa)
+                    break
+
+    def search_intersection(self, start_i, r, n1, n2, airgap_nodes):
+        logger.debug("begin of search_intersection")
+
+        ag_line = Line(Element(start=n1, end=n2))
+        for i in range(start_i, len(airgap_nodes)):
+            n = airgap_nodes[i]
+            alfa = alpha_line(self.center, n)
+            dist_n = distance(self.center, n)
+            p = point(self.center, r, alfa)
+            line = Line(Element(start=self.center, end=p))
+            pts = line.intersect_line(ag_line, include_end=True)
+            if not pts:
+                # no intersection
+                return  # ok
+            if len(pts) != 1:
+                logger.error("-- no intersection found ?!? %s", pts)
+                logger.debug("end of search_intersection: bad")
+                return True  # fatal
+            dist_p = distance(self.center, pts[0])
+            logger.debug("-- check point %s[%s] -- %s[%s]", n, dist_n, pts[0], dist_p)
+            if not less(dist_n, dist_p):
+                logger.debug("end of search_intersection: found")
+                return True  # intersection
+            logger.debug("-- dist %s <= %s", dist_n, dist_p)
+        logger.debug("end of search_intersection: ok")
+        return False  # ok
+
     def print_nodes(self):
         print("=== List of Nodes ({}) ===".format(self.number_of_nodes()))
         for n in self.g.nodes():