Beispiel #1
0
 def on_select(fig, event):
     nonlocal diagram
     if event.xdata is None or event.ydata is None:
         return
     shape = diagram.shape
     self.node = node = dgm_edge.node
     if node > 0 and node < (len(shape)-2):
         inpt = np.array([event.xdata, event.ydata])
         # get the virtual vertex of the combined element surfaces
         vertex = np.array(get_intersect(shape[node-1], shape[node],
                                         shape[node+1], shape[node+2]))
         edge_dir_01 = normalize(shape[node] - shape[node-1])
         edge_dir_23 = normalize(shape[node+2] - shape[node+1])
         # which node is closer to the input point?
         pt1_dist = distance_sqr_2d(shape[node], inpt)
         pt2_dist = distance_sqr_2d(shape[node+1], inpt)
         if pt1_dist < pt2_dist:
             self.filter = calc_coef_fct(vertex, node, edge_dir_01,
                                         node+1, edge_dir_23)
         else:
             self.filter = calc_coef_fct(vertex, node+1, edge_dir_23,
                                         node, edge_dir_01)
         # get direction cosines for the edge
         edge = normalize(shape[node+1] - shape[node])
         # construct perpendicular to the edge. use this to define a
         # range for allowed inputs
         perp_edge = np.array([edge[1], -edge[0]])
         self.bundle = (vertex, edge, perp_edge, edge_dir_01,
                        edge_dir_23)
Beispiel #2
0
    def process_hit_location(self, event, hit_list, prt=False):
        xdata, ydata = self.line.get_data()
        # create a list of vertex coordinates in the model coordinate system
        line_hits = [[xdata[i], ydata[i]] for i in hit_list]
        # transform the list into display coordinates
        dsp_hits = self.line.axes.transData.transform(line_hits)
        hit_pt = [event.x, event.y]

        hit_vertex = None
        hit_edge = None
        min_hit_dist = 1e10
        min_perp_dist = 1e10
        for i, pt in enumerate(dsp_hits):
            # consider hit point as a vertex
            hit_dist = distance_sqr_2d(pt, hit_pt)
            if hit_dist < min_hit_dist:
                min_hit_dist = hit_dist
                if hit_dist < self.pick_radius_sqr:
                    hit_vertex = hit_list[i]

            # consider hit point on an edge
            nxt = hit_list[i] + 1
            try:
                next_pt = np.array([xdata[nxt], ydata[nxt]])
            except IndexError:
                continue
            else:
                next_dsp_pt = self.line.axes.transData.transform(next_pt)
                perp_dist = perpendicular_distance_2d(pt, hit_pt, next_dsp_pt)
                if perp_dist < min_perp_dist:
                    min_perp_dist = perp_dist
                    #                    if perp_dist < self.pick_radius_sqr:
                    #                    print("perp_dist", hit_list[i], perp_dist)
                    hit_edge = hit_list[i]
        v = None
        if hit_vertex is not None:
            v = (hit_vertex, event.xdata, event.ydata, xdata[hit_vertex],
                 ydata[hit_vertex], 's')
#            print("vertex selected %d: event x=%f y=%f data x=%f y=%f" %
#                  (hit_vertex,
#                   event.xdata, event.ydata,
#                   xdata[hit_vertex], ydata[hit_vertex]))
        e = None
        if hit_edge is not None:
            h = hit_edge
            #            print("edge selected", hit_list, min_hit_dist,
            #                  xdata[h:h+2], ydata[h:h+2])
            e = (hit_edge, event.xdata, event.ydata, xdata[h:h + 2],
                 ydata[h:h + 2], '')

        return (v, e)