Ejemplo n.º 1
0
    def getFirstEdgeHit(self, origin: np.array, ray: np.array):
        minDist = 100000000
        hitFound = False
        edgeHit = None
        edgeHitId = -1
        if not self.hasMetaGraph:
            return (hitFound, edgeHit, edgeHitId)
        if self.currentDisplayMode == 0 or self.currentDisplayMode == 2:
            for edge in self.MetaEdgesGL:
                if self.minimizedComponentMap[edge.component]:
                    continue
                p0 = edge.v0
                p1 = edge.v1

                (doesIntersect,
                 distance) = util.intersectRayCylinder(origin, ray, p0, p1,
                                                       edge.scale)
                if not doesIntersect:
                    (doesIntersect, distance) = util.intersectRaySphere(
                        origin, ray, p0, edge.scale)
                if not doesIntersect:
                    (doesIntersect, distance) = util.intersectRaySphere(
                        origin, ray, p1, edge.scale)

                if doesIntersect:
                    if distance < minDist:
                        hitFound = True
                        minDist = distance
                        edgeHit = self.graph.edgeConnections[edge.id]
                        edgeHitId = edge.order

        if self.currentDisplayMode == 1 or self.currentDisplayMode == 2:
            metaEdgeI = -1
            for edgeList in self.SkelEdgesGL:
                metaEdgeI = metaEdgeI + 1
                for edgeGL in edgeList:
                    if self.minimizedComponentMap[edgeGL.component]:
                        continue
                    p0 = edgeGL.v0
                    p1 = edgeGL.v1

                    (doesIntersect, distance) = util.intersectRayCylinder(
                        origin, ray, p0, p1, edgeGL.scale)

                    if doesIntersect:
                        if distance < minDist:
                            hitFound = True
                            minDist = distance
                            edgeHit = self.graph.edgeConnections[metaEdgeI]
                            edgeHitId = metaEdgeI

        if hitFound:
            print('edge hit')
        return (hitFound, edgeHit, edgeHitId)
Ejemplo n.º 2
0
    def getFirstEdgeHit(self, origin: np.array, ray: np.array):
        """
        determines the first edge that is hit by a picking ray
        returns a tuple of (hitDetected, edgeHit, edgeHitId)
        hitDetected : boolean indicator of hit detection
        edgeHit : MetaEdge3d that is hit
        edgeHitId : id of the edge in the skeletons edgeList
        """
        print('detecting hits')
        minDist = 100000000
        hitFound = False
        edgeHit = None
        edgeHitId = -1
        if not self.hasMetaGraph:
            return (hitFound, edgeHit, edgeHitId)
        i = 0
        for edge in self.metaGraph.edgeConnections:

            p0 = self.metaGraph.nodeLocations[edge.node0]
            p1 = self.metaGraph.nodeLocations[edge.node1]
            if isinstance(p0, Point3d) or isinstance(p0, MetaNode3d):
                p0 = drawingUtil.p3d2arr(p0)
                p1 = drawingUtil.p3d2arr(p1)

            (doesIntersect,
             distance) = util.intersectRayCylinder(origin, ray, p0, p1,
                                                   edge.thickness)
            if not doesIntersect:
                (doesIntersect,
                 distance) = util.intersectRaySphere(origin, ray, p0,
                                                     edge.thickness)
            if not doesIntersect:
                (doesIntersect,
                 distance) = util.intersectRaySphere(origin, ray, p1,
                                                     edge.thickness)

            if doesIntersect:
                if distance < minDist:
                    hitFound = True
                    minDist = distance
                    edgeHit = edge
                    edgeHitId = edge.order
            i = i + 1

        if hitFound:
            print('hit detected')
            self.printMetaEdge(edgeHit)
        else:
            print('no hit detected')
        return (hitFound, edgeHit, edgeHitId)
Ejemplo n.º 3
0
    def getFirstNodeHit(self, origin: np.array, ray: np.array):
        print('detecting node hits')
        minDist = 1000000000
        hitFound = False
        nodeHit = None
        nodeHitId = -1

        if not self.hasMetaGraph:
            return (hitFound, nodeHit, nodeHitId)

        i = 0
        for node in self.metaGraph.nodeLocations:
            p = drawingUtil.p3d2arr(node)
            (doesIntersect,
             distance) = util.intersectRaySphere(origin, ray, p,
                                                 self.nodeSizeMap[i])

            if doesIntersect:
                if distance < minDist:
                    hitFound = True
                    minDist = distance
                    nodeHit = node
                    nodeHitId = i
            i = i + 1

        if hitFound:
            print('hit detected')
            self.printMetaNode(nodeHit)
        else:
            print('no hit detected')

        return (hitFound, nodeHit, nodeHitId)
Ejemplo n.º 4
0
    def getFirstNodeHit(self, origin: np.array, ray: np.array):
        minDist = 1000000000
        hitFound = False
        nodeHit = None
        nodeHitId = -1

        if not self.hasMetaGraph:
            return (hitFound, nodeHit, nodeHitId)

        for node in self.MetaNodesGL:
            if self.minimizedComponentMap[node.component]:
                continue
            p = node.v0
            (doesIntersect,
             distance) = util.intersectRaySphere(origin, ray, p, node.scale)

            if doesIntersect:
                if distance < minDist:
                    hitFound = True
                    minDist = distance
                    nodeHit = self.graph.nodeLocations[node.id]
                    nodeHitId = node.id
        if hitFound:
            print('node hit')
        return (hitFound, nodeHit, nodeHitId)