femagtools 1.5.7__py3-none-any.whl → 1.6.1__py3-none-any.whl

femagtools/dxfsl/geom.py

@@ -16,7 +16,8 @@ import logging
 import sys
 from .corner import Corner
 from .area import Area
-from .shape import Element, Shape, Circle, Arc, Line, Point, is_Circle
+from .shape import Element, Shape, Circle, Arc, Line, Point
+from .shape import is_Circle, is_Arc, is_Line
 from .machine import Machine
 from .functions import less_equal, less, greater, greater_equal
 from .functions import distance, alpha_line, alpha_points, alpha_angle
@@ -112,10 +113,17 @@ def add_or_split(el, x, out_elements, rtol, atol):
             out_elements[x] = None
         split_el = el.split(points, rtol, atol)
         return split_el
-
     return []
 
 
+def add_element(geom, e, rtol, atol):
+    n = geom.find_nodes(e.start(), e.end())
+    try:
+        add_or_join(geom, n[0], n[1], e, rtol, atol)
+    except Exception as ex:
+        logger.warn("EXCEPTION in add_element: %s", ex)
+
+
 def add_or_join(geom, n1, n2, entity, rtol, atol):
     """ adds a new entity to graph or joins entity with existing
     geom: Geometry
@@ -125,8 +133,52 @@ def add_or_join(geom, n1, n2, entity, rtol, atol):
     if n1 == n2:
         logger.debug(
             "Tiny element with same node on both sides ignored: %s", n1)
-    else:
+        logger.debug(
+            " -- element: %s", entity)
+        return
+
+    e = geom.get_edge_element(n1, n2)
+    if not e:  # no duplicates
         geom.add_edge(n1, n2, entity)
+        return
+
+    logger.debug("Duplicate connection: %s <--> %s", n1, n2)
+    if is_Line(e):
+        if is_Line(entity):
+            logger.debug("add_or_join(): Duplicate Lines ignored")
+            return  # its ok
+
+    if is_Arc(e):
+        if is_Arc(entity):
+            if points_are_close(e.center, entity.center, rtol=rtol, atol=atol):
+                if points_are_close(e.p1, entity.p1):
+                    logger.debug("add_or_join(): Duplicate Arcs ignored")
+                    return  # its ok
+
+    if is_Circle(entity):
+        if is_Circle(e):
+            logger.debug("add_or_join(): Duplicate Circle ignored")
+            return  # its ok
+
+    if is_Circle(entity) or is_Circle(e):
+        e1, e2 = entity.cut_into_halves()
+        logger.debug("===== add_or_join(): Element near circle is cut into halves =====")
+        add_element(geom, e1, rtol, atol)
+        add_element(geom, e2, rtol, atol)
+        return  # halves installed
+
+    m1 = e.center_of_connection()
+    m2 = entity.center_of_connection()
+    logger.debug("midpoints: %s -- %s", m1, m2)
+    if points_are_close(m1, m2, rtol, 1e-2):
+        logger.debug("Elements are close together")
+        return  # ok
+
+    e1, e2 = entity.cut_into_halves()
+    logger.debug("===== add_or_join(): cut into halves =====")
+    add_element(geom, e1, rtol, atol)
+    add_element(geom, e2, rtol, atol)
+    return  # halves installed
 
 
 def get_nodes_of_paths(g, c):
@@ -221,7 +273,7 @@ def polylines(entity, lf, rf, xoff=0.0, yoff=0.0, rotation=0.0):
         p1 = points[i]
         try:
             p2 = points[i+1]
-        except Exception as e:
+        except Exception:
             if not entity.is_closed:
                 break
             p2 = points[0]
@@ -276,6 +328,7 @@ 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
@@ -294,7 +347,7 @@ def ellipse(entity, lf, xoff=0.0, yoff=0.0, rotation=0.0):
     x, y = np.dot(R, [x, y])
     x += entity.center[0]
     y += entity.center[1]
-    points = np.array((x,y)).T
+    points = np.array((x, y)).T
     p1 = points[0]
     for p2 in points[1:]:
         yield Line(Element(start=p1, end=p2), lf,
@@ -488,7 +541,7 @@ def dxfshapes(dxffile, mindist=0.01, layers=[]):
     # dwg.header['$LUNITS']
     lf = 1
     if dwg.header.get('$LUNITS', 0) == 1:
-        #conv = [1, 2.54e-2, 10.12, 633.0, 1e-3, 1e-2, 1]
+        # conv = [1, 2.54e-2, 10.12, 633.0, 1e-3, 1e-2, 1]
         lf = 2.54e3
 
     rf = np.pi/180
@@ -919,11 +972,13 @@ class Geometry(object):
 
     def add_edge(self, n1, n2, entity):
         if points_are_close(n1, n2):
-            logger.debug("WARNING in add_edge(): Points ar close together")
-            logger.debug("        p1 = %s, p2 = %s", n1, n2)
+            logger.debug("WARNING in add_edge(): Points of %s are close together",
+                         entity.classname())
+            logger.debug("        n1 = %s, n2 = %s", n1, n2)
+            logger.debug("        p1 = %s, p2 = %s", entity.p1, entity.p2)
 
         entity.set_nodes(n1, n2)
-        logger.debug("add_edge %s - %s", n1, n2)
+        logger.debug("add_edge %s - %s  (%s)", n1, n2, entity.classname())
         self.g.add_edge(n1, n2, object=entity)
 
     def get_edge(self, eg):
@@ -984,7 +1039,6 @@ class Geometry(object):
                     self.rtol,
                     self.atol)
 
-
     def elements(self, type):
         """return lists of objects"""
         return [e[2]['object'] for e in self.g.edges(data=True)
@@ -1004,19 +1058,19 @@ class Geometry(object):
         rem_lines = []
         for p1, p2, data in [e for e in self.g.edges(data=True)
                              if isinstance(e[2]['object'], Line)]:
-            l = data['object']
-            if l.length() > length:
-                p = l.center_of_connection()
-                new_lines += l.split([p])
+            ln = data['object']
+            if ln.length() > length:
+                p = ln.center_of_connection()
+                new_lines += ln.split([p])
                 rem_lines.append((p1, p2))
 
         for p1, p2 in rem_lines:
             self._remove_edge(p1, p2)
-        for l in new_lines:
+        for new_ln in new_lines:
             add_or_join(self,
-                        l.node1(ndec),
-                        l.node2(ndec),
-                        l,
+                        new_ln.node1(ndec),
+                        new_ln.node2(ndec),
+                        new_ln,
                         self.rtol,
                         self.atol)
 
@@ -1055,12 +1109,13 @@ class Geometry(object):
         # Linie als Corner-Objekte.
         corners = [Corner(center, c)
                    for c in self.angle_nodes(center, angle, rtol, atol)]
+        center_added = len(corners) == 1
         if len(corners) == 1:
             logger.debug('get_corner_list: the center is a corner')
             corners.append(Corner(center, tuple(center)))
         if len(corners) > 1:
             corners.sort()
-        return corners
+        return center_added, corners
 
     def start_min_corner(self, i):
         return self.start_corners[0][i]
@@ -1151,13 +1206,15 @@ class Geometry(object):
         end_pts = [p for p in reversed(self.end_corners)]
         return area_size(pts + end_pts)
 
-    def repair_hull_line(self, center, angle, corners, with_center):
+    def repair_hull_line(self, center, angle, corners, with_center, rtol=None, atol=None):
         # We need to set our own tolerance range
         # to find the right points
-        rtol = 1e-4
-        atol = 1e-4
+        if not rtol:
+            rtol = 1e-3
+        if not atol:
+            atol = 1e-3
 
-        logger.debug("repair_hull_line(center=%s, angle=%s)", center, angle)
+        logger.debug("begin repair_hull_line(center=%s, angle=%s)", center, angle)
 
         if len(corners) < 2:
             # no hull without more than 1 corners
@@ -1182,6 +1239,7 @@ class Geometry(object):
                 # Both points are in the hull
                 el = data['object']
                 if isinstance(el, Line):
+                    logger.debug("remove Line: %s <> %s", p1, p2)
                     self._remove_edge(p1, p2)
                 else:
                     [corner.set_keep_node() for corner in clist_p1]
@@ -1216,7 +1274,9 @@ class Geometry(object):
             logger.warn("Warning: %s", e)
 
         # Rebuild Corner-list after correction
-        corners = self.get_corner_list(center, angle, rtol, atol)
+        center_added, corners = self.get_corner_list(center, angle, rtol, atol)
+        for c in corners:
+            logger.debug("Correct Corner: %s", c)
 
         if with_center:
             c_corner = Corner(center, tuple(center))
@@ -1253,10 +1313,10 @@ class Geometry(object):
         if not self.center:
             raise ValueError("FATAL ERROR: no center in Geometry")
 
-        corners = self.get_corner_list(self.center, angle)
+        center_added, corners = self.get_corner_list(self.center, angle)
         assert(corners)
-        c_min = Corner(center, point(self.center, self.min_radius, angle, ndec))
-        c_max = Corner(center, point(self.center, self.max_radius, angle, ndec))
+        c_min = Corner(self.center, point(self.center, self.min_radius, angle, ndec))
+        c_max = Corner(self.center, point(self.center, self.max_radius, angle, ndec))
 
         c_first = corners[0]
         if not c_min.is_same_corner(c_first):
@@ -1276,7 +1336,7 @@ class Geometry(object):
 
     def complete_hull_arc(self, startangle, startcorner,
                           endangle, endcorner, radius):
-        nodes = self.radius_nodes(center, radius, 1e-04, 1e-04)
+        nodes = self.radius_nodes(self.center, radius, 1e-04, 1e-04)
 
         if startcorner.is_new_point:
             start_p = startcorner.point()
@@ -1284,9 +1344,9 @@ class Geometry(object):
                             if not points_are_close(start_p, n)]
             nodes_sorted.sort()
             p = nodes_sorted[0][1]
-            angle_p = alpha_line(center, p)
+            angle_p = alpha_line(self.center, p)
             self.add_edge(start_p, p, Arc(
-                Element(center=center, radius=radius,
+                Element(center=self.center, radius=radius,
                         start_angle=startangle*180/np.pi,
                         end_angle=angle_p*180/np.pi)))
 
@@ -1296,9 +1356,9 @@ class Geometry(object):
                             if not points_are_close(end_p, n)]
             inx = len(nodes_sorted)-1
             p = nodes_sorted[inx][1]
-            angle_p = alpha_line(center, p)
+            angle_p = alpha_line(self.center, p)
             self.add_edge(p, end_p, Arc(
-                Element(center=center, radius=radius,
+                Element(center=self.center, radius=radius,
                         start_angle=angle_p*180/np.pi,
                         end_angle=endangle*180/np.pi)))
 
@@ -1306,7 +1366,7 @@ class Geometry(object):
         rtol = 1e-4
         atol = 1e-4
 
-        corners = self.get_corner_list(center, angle, rtol, atol)
+        center_added, corners = self.get_corner_list(center, angle, rtol, atol)
         if len(corners) < 2:
             return ()  # not enough corners
         return (corners[0].point(), corners[len(corners)-1].point())
@@ -1693,7 +1753,7 @@ class Geometry(object):
     def the_point_is_inside(self, p, rtol=1e-04, atol=1e-04):
         for e in self.elements(Shape):
             if e.is_point_inside(p, rtol=rtol, atol=atol, include_end=True):
-                #logger.info("point %s is inside %s", p, e)
+                # logger.info("point %s is inside %s", p, e)
                 return True
         return False
 
@@ -1824,13 +1884,14 @@ class Geometry(object):
         alpha_start = alpha_line(e.center, e.p1)
         for x, p2 in sorted_points:
             alpha_end = alpha_line(e.center, p2)
-            pm = middle_point_of_arc(e.center, e.radius, p1, p2, rtol=rtol)
+            pm = middle_point_of_arc(e.center, e.radius, p1, p2, rtol=rtol, atol=atol)
             if is_point_inside_region(pm, center,
-                                      inner_circle.radius, outer_circle.radius,
-                                      start_angle, end_angle):
-
+                                      inner_circle.radius,
+                                      outer_circle.radius,
+                                      start_angle, end_angle,
+                                      rtol=rtol, atol=atol):
                 if not (len(points) > 1 and
-                        points_are_close(p1, p2, 1e-3, 1e-3)):
+                        points_are_close(p1, p2, rtol=rtol, atol=atol)):
                     if len(points) == 1 and e.rtheta is not None:
                         a = Arc(Element(center=e.center,
                                         radius=e.radius,
@@ -1846,7 +1907,9 @@ class Geometry(object):
                                         radius=e.radius,
                                         start_angle=alpha_start*180/np.pi,
                                         end_angle=alpha_end*180/np.pi))
-
+                    if points_are_close(a.p1, a.p2, rtol=1e-02, atol=1e-02):
+                        logger.debug("ATTENTION: creation of a tiny arc")
+                        a.set_attribute("tiny")
                     new_elements.append(a)
             alpha_start = alpha_end
             p1 = p2
@@ -1862,7 +1925,6 @@ class Geometry(object):
             durch die Parameter definierten Teilkreisfläche befinden.
         """
         assert(isinstance(e, Circle))
-
         if is_same_angle(start_angle, end_angle):
             pts_inner = inner_circle.intersect_circle(e,
                                                       rtol,
@@ -1912,47 +1974,24 @@ class Geometry(object):
         sorted_points.sort()
 
         x, px = sorted_points[0]
-        del sorted_points[0]
+        sorted_points.append((x, px))
         p1 = px
         alpha_start = alpha_line(e.center, p1)
-        for x, p2 in sorted_points:
+        for x, p2 in sorted_points[1:]:
             alpha_end = alpha_line(e.center, p2)
-            pm = middle_point_of_arc(e.center, e.radius, p1, p2, rtol=rtol)
+            pm = middle_point_of_arc(e.center, e.radius, p1, p2, rtol=rtol, atol=atol)
             if is_point_inside_region(pm, center,
                                       inner_circle.radius,
                                       outer_circle.radius,
-                                      start_angle, end_angle):
-                alpha_middle = middle_angle(alpha_start, alpha_end)
-                arc1 = Arc(Element(center=e.center,
-                                   radius=e.radius,
-                                   start_angle=alpha_start*180/np.pi,
-                                   end_angle=alpha_middle*180/np.pi))
-                arc2 = Arc(Element(center=e.center,
-                                   radius=e.radius,
-                                   start_angle=alpha_middle*180/np.pi,
-                                   end_angle=alpha_end*180/np.pi))
-                new_elements.append(arc1)
-                new_elements.append(arc2)
-
+                                      start_angle, end_angle,
+                                      rtol=rtol, atol=atol):
+                a = Arc(Element(center=e.center,
+                                radius=e.radius,
+                                start_angle=alpha_start*180/np.pi,
+                                end_angle=alpha_end*180/np.pi))
+                new_elements.append(a)
             alpha_start = alpha_end
             p1 = p2
-
-        alpha_end = alpha_line(e.center, px)
-        pm = middle_point_of_arc(e.center, e.radius, p1, px, rtol=rtol)
-        if is_point_inside_region(pm, center,
-                                  inner_circle.radius, outer_circle.radius,
-                                  start_angle, end_angle):
-            alpha_middle = middle_angle(alpha_start, alpha_end)
-            arc1 = Arc(Element(center=e.center,
-                               radius=e.radius,
-                               start_angle=alpha_start*180/np.pi,
-                               end_angle=alpha_middle*180/np.pi))
-            arc2 = Arc(Element(center=e.center,
-                               radius=e.radius,
-                               start_angle=alpha_middle*180/np.pi,
-                               end_angle=alpha_end*180/np.pi))
-            new_elements.append(arc1)
-            new_elements.append(arc2)
         return new_elements
 
     def copy_shape(self,
@@ -1966,16 +2005,20 @@ class Geometry(object):
                    atol=0.0,
                    append_inner=False,
                    append_outer=False,
-                   delete_appendices=False):
+                   delete_appendices=False,
+                   concatenate_tiny_el=False):
         """ Die Funktion kopiert die Teile von Shape-Objekten, welche sich in
             der durch die Parameter definierten Teilkreisfläche befinden.
         """
-        logger.debug('copy_shape(%s, %s)', startangle, endangle)
+        logger.debug('begin copy_shape(%s, %s)', startangle, endangle)
 
         if not rtol:
             rtol = self.rtol
         if not atol:
             atol = self.atol
+        rtol = 1e-5
+        atol = 1e-4
+        logger.debug(' -> rtol=%s,  atol=%s', rtol, atol)
 
         if is_same_angle(startangle, endangle):
             start_line = Line(
@@ -2028,7 +2071,6 @@ class Geometry(object):
                     atol=atol,
                     points_inner=pts_inner,
                     points_outer=pts_outer)
-
             elif isinstance(e, Circle):
                 new_elements += self.copy_circle(
                     self.center, radius, startangle, endangle,
@@ -2065,6 +2107,11 @@ class Geometry(object):
                 new_elements.append(arc)
                 p1 = p2
 
+        if concatenate_tiny_el:
+            ok, new_elements = self.concatenate_tiny_elements(new_elements)
+            if ok:
+                split = True
+
         if delete_appendices:
             center = []
         else:
@@ -2074,8 +2121,8 @@ class Geometry(object):
             logger.debug('new Geometry with split')
             geom = Geometry(new_elements,
                             center=center,
-                            rtol=0.05,
-                            atol=0.1,
+                            rtol=self.rtol,
+                            atol=self.atol,
                             is_inner=self.is_inner,
                             is_outer=self.is_outer,
                             split=split)
@@ -2090,7 +2137,7 @@ class Geometry(object):
         if delete_appendices:
             geom.delete_all_appendices()
             geom.set_center(self.center)
-
+        logger.debug('end copy_shape')
         return geom
 
     def copy_all_elements(self, alpha):
@@ -2149,6 +2196,78 @@ class Geometry(object):
                 return False
         return True
 
+    def concatenate_arc_elements(self, el, elements):
+        if not is_Arc(el):
+            return False
+
+        def match(e1, e2):
+            if e2.has_attribute("del"):
+                return False
+            if e2.has_attribute("tiny"):
+                return False
+            if not points_are_close(e1.center, e2.center):
+                return False
+            return np.isclose(e1.radius, e2.radius)
+
+        elmts = [(e.p1, e) for e in elements if is_Arc(e) and match(el, e)]
+        elmts.sort()
+
+        ok = False
+        for p, e in elmts:
+            el_new = el.concatenate(None, None, e)
+            if el_new:
+                el.set_attribute("del")
+                e.set_attribute("del")
+                elements.append(el_new)
+                el = el_new
+                ok = True
+        return ok
+
+    def concatenate_line_elements(self, el, elements):
+        if not is_Line(el):
+            return False
+
+        def match(e1, e2):
+            if e2.has_attribute("del"):
+                return False
+            if e2.has_attribute("tiny"):
+                return False
+            return np.isclose(e1.m(999999.0), e2.m(999999.0))
+
+        elmts = [(e.p1, e) for e in elements if is_Line(e) and match(el, e)]
+        elmts.sort()
+
+        ok = False
+        for p, e in elmts:
+            el_new = el.concatenate(None, None, e)
+            if el_new:
+                el.set_attribute("del")
+                e.set_attribute("del")
+                elements.append(el_new)
+                el = el_new
+                ok = True
+        return ok
+
+    def concatenate_tiny_elements(self, new_elements):
+        logger.debug("begin concatenate_tiny_elements")
+        tiny_elements = [e for e in new_elements if e.has_attribute("tiny")]
+        if not tiny_elements:
+            logger.debug("end concatenate_tiny_elements: (%s elements)", 0)
+            return False, new_elements
+
+        count = 0
+        for e_tiny in tiny_elements:
+            if is_Line(e_tiny):
+                if self.concatenate_line_elements(e_tiny, new_elements):
+                    count += 1
+            elif is_Arc(e_tiny):
+                if self.concatenate_arc_elements(e_tiny, new_elements):
+                    count += 1
+
+        new_list = [e for e in new_elements if not e.has_attribute("del")]
+        logger.debug("end concatenate_tiny_elements: (%s elements)", count)
+        return count>0, new_list
+
     def find_symmetry(self, radius,
                       startangle, endangle, sym_tolerance):
         arealist = self.list_of_areas()
@@ -2450,7 +2569,7 @@ class Geometry(object):
         elif np.isclose(width*2, height, self.rtol, self.atol):
             radius = width
             logger.info("check for half machine")
-            set_center([mm[1], mm[3]-width])
+            self.set_center([mm[1], mm[3]-width])
             if self.check_hull(radius, mm[1], None, self.rtol, atol):
                 logger.info(" - it is a half")
                 return Machine(self, radius, np.pi/2.0, -np.pi/2.0)
@@ -2922,7 +3041,7 @@ class Geometry(object):
                 else:
                     logger.warning("   %s already removed ?!", id)
 
-        #for area in self.list_of_areas():
+        # for area in self.list_of_areas():
         #    logger.info("Inside %s is:", area.identifier())
         #    for id in area.areas_inside:
         #        logger.info(" ++ %s", id)
@@ -3189,27 +3308,29 @@ class Geometry(object):
                 if a.is_point_inside(p):
                     return a.id
             return 0
+
         #   -------------------------
         def connection_thru_main_area(pts):
             if len(pts) < 3:
-                return True  #ok
+                return True  # ok
             if len(areas_inside) < 2:
-                return True  #ok
+                return True  # ok
 
             id = id_of_inside_area(pts[0])
             if id == 0:  # strange
-                return False  #bad
+                return False  # bad
 
             next_id = id_of_inside_area(pts[1])
             if next_id == 0:
-                return True  #ok
+                return True  # ok
 
             id = next_id
             next_id = id_of_inside_area(pts[2])
             if id == next_id:  # thru inside-area
-                return True  #ok
+                return True  # ok
 
             return False
+
         #   ----------
         def takeSecond(elem):
             return elem[1]
@@ -3243,7 +3364,7 @@ class Geometry(object):
                           color=aux_color,
                           linestyle=aux_linestyle)
                 arc.set_attribute('iron_sep')
-                p = self.split_and_get_intersect_points(arc)
+                self.split_and_get_intersect_points(arc)
                 n = self.find_nodes(pts[0], pts[1])
                 self.add_edge(n[0], n[1], arc)
 
@@ -3745,7 +3866,7 @@ class Geometry(object):
                     try:
                         self._remove_edge(n0, n1)
                         self.add_edge(nn, n1, el)
-                    except Exception as e:
+                    except Exception:
                         logger.debug("delete of %s - %s failed", n0, n)
                         logger.debug("Element %s", el)
         return c