Python math.hypot() Examples

def animate(self):
        self.angle += (math.pi / 30)
        xs = 200 * math.sin(self.angle) - 40 + 25
        ys = 200 * math.cos(self.angle) - 40 + 25
        self.m_lightSource.setPos(xs, ys)

        for item in self.m_items:
            effect = item.graphicsEffect()

            delta = QPointF(item.x() - xs, item.y() - ys)
            effect.setOffset(QPointF(delta.toPoint() / 30))

            dd = math.hypot(delta.x(), delta.y())
            color = effect.color()
            color.setAlphaF(max(0.4, min(1 - dd / 200.0, 0.7)))
            effect.setColor(color)

        self.m_scene.update() 

def __init__(self):
        super(StickMan, self).__init__()

        self.m_sticks = True
        self.m_isDead = False
        self.m_pixmap = QPixmap('images/head.png')
        self.m_penColor = QColor(Qt.white)
        self.m_fillColor = QColor(Qt.black)

        # Set up start position of limbs.
        self.m_nodes = []
        for x, y in Coords:
            node = Node(QPointF(x, y), self)
            node.positionChanged.connect(self.childPositionChanged)
            self.m_nodes.append(node)

        self.m_perfectBoneLengths = []
        for n1, n2 in Bones:
            node1 = self.m_nodes[n1]
            node2 = self.m_nodes[n2]

            dist = node1.pos() - node2.pos()
            self.m_perfectBoneLengths.append(math.hypot(dist.x(), dist.y()))

        self.startTimer(10) 

def warpImage(src, theta, phi, gamma, scale, fovy):
    halfFovy = fovy * 0.5
    d = math.hypot(src.shape[1], src.shape[0])
    sideLength = scale * d / math.cos(deg2Rad(halfFovy))
    sideLength = np.int32(sideLength)

    M = warpMatrix(src.shape[1], src.shape[0], theta, phi, gamma, scale, fovy)
    dst = cv2.warpPerspective(src, M, (sideLength, sideLength))
    mid_x = mid_y = dst.shape[0] // 2
    target_x = target_y = src.shape[0] // 2
    offset = (target_x % 2)

    if len(dst.shape) == 3:
        dst = dst[mid_y - target_y:mid_y + target_y + offset,
              mid_x - target_x:mid_x + target_x + offset,
              :]
    else:
        dst = dst[mid_y - target_y:mid_y + target_y + offset,
              mid_x - target_x:mid_x + target_x + offset]

    return dst 

def gen_adj_mat(longs, lats, prob_edge=.2,
                        additional_length=lambda: np.random.exponential(20,1)):
    '''Get an adjacency matrix for the cities whose longitudes and latitudes
    are passed. Each entry will either be a number somewhat greater than the
    crow-flies distance between the two cities (with probability prob_edge),
    or math.inf. The matrix will consist of floats, and be symmetric. The
    diagonal will be all zeroes. The "somewhat greater" is controlled by the
    additional_length parameter, a function returning a random amount.'''

    # Generate full nxn Bernoulli's, even though we'll only use the upper
    # triangle.
    edges = np.random.binomial(1, prob_edge, size=(len(longs),len(longs)))
    am = np.zeros((len(longs),len(longs)))
    for i in range(len(longs)):
        for j in range(len(longs)):
            if i==j:
                am[i,i] = 0
            elif i < j:
                if edges[i,j] == 1:
                    am[i,j] = (math.hypot(longs[i]-longs[j],lats[i]-lats[j])
                        + additional_length())
                    am[j,i] = am[i,j]
                else:
                    am[i,j] = am[j,i] = math.inf
    return np.around(am,1) 

def get_camera_params(box, size, view_angle):
    box_size = box.size()

    size_diagonal = math.hypot(*size)

    if view_angle is None:
        focal_length = size_diagonal  # Normal lens by default
    else:
        focal_length = size_diagonal / (2 * math.tan(math.radians(view_angle) / 2))

    distance = focal_length * max(_zero_if_inf(box_size.x) / size[0],
                                  _zero_if_inf(box_size.z) / size[1])

    if distance == 0:
        distance = 1

    distance *= 1.2  # 20% margin around the object

    origin = box.midpoint() - util.Vector(0, distance + _zero_if_inf(box_size.y) / 2, 0)
    direction = util.Vector(0, 1, 0)
    up = util.Vector(0, 0, 1)

    return (origin, direction, up, focal_length) 

def get_camera_params(box, size, view_angle):
    box_size = box.size()

    size_diagonal = math.hypot(*size)

    if view_angle is None:
        focal_length = size_diagonal  # Normal lens by default
    else:
        focal_length = size_diagonal / (2 * math.tan(math.radians(view_angle) / 2))

    distance = focal_length * max(_zero_if_inf(box_size.x) / size[0],
                                  _zero_if_inf(box_size.z) / size[1])

    if distance == 0:
        distance = 1

    distance *= 1.2  # 20% margin around the object

    origin = box.midpoint() - util.Vector(0, distance + _zero_if_inf(box_size.y) / 2, 0)
    direction = util.Vector(0, 1, 0)
    up = util.Vector(0, 0, 1)

    return (origin, direction, up, focal_length) 

def drawBallVelocity(self, painter):
        ballPos = self.ballOdom.pose.pose.position
        ballVel = self.ballOdom.twist.twist.linear

        if math.hypot(ballVel.x, ballVel.y) < 1.0:
            return 

        angleOfSpeed = math.atan2(ballVel.y, ballVel.x)

        paintDist = 10.0

        velPosX = paintDist * math.cos(angleOfSpeed) + ballPos.x
        velPosY = paintDist * math.sin(angleOfSpeed) + ballPos.y

        ballPosPoint = self.convertToDrawWorld(ballPos.x, ballPos.y)
        velPosPoint = self.convertToDrawWorld(velPosX, velPosY)

        painter.setPen(QPen(QColor(102,0,255),2))
        painter.drawLine(ballPosPoint, velPosPoint) 

def setup_xy(self, p1_world, p2_world, p1_ucs, p2_ucs):
        """ setup an UCS given by the points p1 and p2
        only xy-plane,  z' = z
        """
        ucs_angle_to_x_axis = get_angle(p1_ucs, p2_ucs)
        world_angle_to_x_axis = get_angle(p1_world, p2_world)
        rotation = normalize_angle(world_angle_to_x_axis - ucs_angle_to_x_axis)
        self._xaxis = (math.cos(rotation), math.sin(rotation), 0.)
        self._yaxis = (math.cos(rotation+HALF_PI), math.sin(rotation+HALF_PI), 0.)
        self._zaxis = (0., 0., 1.)

        ucs_angle_to_x_axis = get_angle((0., 0.), p1_ucs)
        world_angle_to_x_axis = rotation + ucs_angle_to_x_axis
        distance_from_ucs_origin = math.hypot(p1_ucs[0], p1_ucs[1])
        delta_x = distance_from_ucs_origin * math.cos(world_angle_to_x_axis)
        delta_y = distance_from_ucs_origin * math.sin(world_angle_to_x_axis)
        self._origin = (p1_world[0] - delta_x, p1_world[1] - delta_y, 0.) 

def manipulate_frame(self, frame_image, faces, index):
        # Instantiates a client
        googly_eye = Image.open(self.__class__.get_os_path('overlays/eye.png'))

        for face in faces:

            for side in ('left', 'right'):

                ((lcx, lcy), (ex, ey), (rcx, rcy)) = face.get_eye_coords(side)

                ew = int(1.5 * math.hypot(rcx - lcx, rcy - lcy))

                pasted = googly_eye.rotate(random.randint(0, 360), Image.BICUBIC).resize((ew, ew), Image.BICUBIC)
                frame_image.paste(pasted, (int(ex - ew/2), int(ey - ew/2)), pasted)

        return frame_image 

def cry_frame(self, frame_image, faces, index):
        # Instantiates a client
        tear = Image.open(self.__class__.get_os_path('overlays/tearblood.png'))

        lowest = 0

        for face in faces:

            for side in ('left', 'right'):

                ((lcx, lcy), (ex, ey), (rcx, rcy)) = face.get_eye_coords(side)

                ew = int(1.25 * math.hypot(rcx - lcx, rcy - lcy))

                pasted = tear.resize((ew, ew), Image.BICUBIC)
                left_y = int(lcy + (index * ew * 1.5) + (ew * .75))
                right_y = int(rcy + (index * ew * 1.5) + (ew * .5) )
                frame_image.paste(pasted, (int(lcx - ew/2), left_y), pasted)
                frame_image.paste(pasted, (int(rcx - ew/2), right_y), pasted)
                lowest = max(left_y, right_y)

        return lowest 

def cry_frame(self, frame_image, faces, index):
        # Instantiates a client
        tear = Image.open(self.__class__.get_os_path('overlays/tear.png'))

        lowest = 0

        for face in faces:

            for side in ('left', 'right'):

                ((lcx, lcy), (ex, ey), (rcx, rcy)) = face.get_eye_coords(side)

                ew = int(1.25 * math.hypot(rcx - lcx, rcy - lcy))

                pasted = tear.resize((ew, ew), Image.BICUBIC).rotate(face.angles.tilt, Image.BICUBIC)
                left_y = int(lcy + (index * ew * 1.5) + (ew * .5))
                right_y = int(rcy + (index * ew * 1.5) + (ew * .75) )
                frame_image.paste(pasted, (int(lcx - ew/2), left_y), pasted)
                frame_image.paste(pasted, (int(rcx - ew/2), right_y), pasted)
                lowest = max(left_y, right_y)

        return lowest 

def __init__(self, dot_widget, target_x, target_y):
        MoveToAnimation.__init__(self, dot_widget, target_x, target_y)
        self.source_zoom = dot_widget.zoom_ratio
        self.target_zoom = self.source_zoom
        self.extra_zoom = 0

        middle_zoom = 0.5 * (self.source_zoom + self.target_zoom)

        distance = math.hypot(self.source_x - self.target_x,
                              self.source_y - self.target_y)
        rect = self.dot_widget.get_allocation()
        visible = min(rect.width, rect.height) / self.dot_widget.zoom_ratio
        visible *= 0.9
        if distance > 0:
            desired_middle_zoom = visible / distance
            self.extra_zoom = min(0, 4 * (desired_middle_zoom - middle_zoom)) 

def arcMidPoint(self, prev_vertex, vertex, angle):
        if len(prev_vertex) == 3:
            [x1, y1, z1] = prev_vertex
        else:
            [x1, y1] = prev_vertex
            
        if len(vertex) == 3:
            [x2, y2, z2] = vertex
        else:
            [x2, y2] = vertex
        
        angle = radians(angle / 2)
        basic_angle = atan2(y2 - y1, x2 - x1) - pi / 2
        shift = (1 - cos(angle)) * hypot(y2 - y1, x2 - x1) / 2 / sin(angle)
        midpoint = [(x2 + x1) / 2 + shift * cos(basic_angle), (y2 + y1) / 2 + shift * sin(basic_angle)]
        
        return midpoint 

def __init__(self, dot_widget, target_x, target_y):
        MoveToAnimation.__init__(self, dot_widget, target_x, target_y)
        self.source_zoom = dot_widget.zoom_ratio
        self.target_zoom = self.source_zoom
        self.extra_zoom = 0

        middle_zoom = 0.5 * (self.source_zoom + self.target_zoom)

        distance = math.hypot(self.source_x - self.target_x,
                              self.source_y - self.target_y)
        rect = self.dot_widget.get_allocation()
        visible = min(rect.width, rect.height) / self.dot_widget.zoom_ratio
        visible *= 0.9
        if distance > 0:
            desired_middle_zoom = visible / distance
            self.extra_zoom = min(0, 4 * (desired_middle_zoom - middle_zoom)) 

def dft(self, data, typecode='h'):
        if type(data) is str:
            a = array.array(typecode, data)
            for index, value in enumerate(a):
                self.real_input[index] = float(value)
        elif type(data) is array.array:
            for index, value in enumerate(data):
                self.real_input[index] = float(value)

        self.fftwf_execute(self.fftwf_plan)

        for i in range(len(self.amplitude)):
            self.amplitude[i] = math.hypot(self.complex_output[i * 2], self.complex_output[i * 2 + 1])
            # self.phase[i] = math.atan2(self.complex_output[i * 2 + 1], self.complex_output[i * 2])

        return self.amplitude  # , self.phase 

def start(self, route=[], v=10):
        r = route

        self.TopSpeed = v
        self.Route = r

        # Calculating position and velocity vector according to route points
        if len(route) > 1:
            self.CurrentRoute += 1
            self.Position = Vector3(r[0]['X'], r[0]['Y'], self.Position.Z)

            ddash = math.hypot(self.Position.X-r[1]['X'], self.Position.Y-r[1]['Y'])
            self.Velocity = Vector3((v/ddash) * (r[1]['X']-self.Position.X), (v/ddash) * (r[1]['Y']-self.Position.Y), 0)
        else:
            self.Position = Vector3(0, 0, self.Position.Z)
            self.Velocity = Vector3(0, 0, 0) 

def animate(self):
        self.angle += (math.pi / 30)
        xs = 200 * math.sin(self.angle) - 40 + 25
        ys = 200 * math.cos(self.angle) - 40 + 25
        self.m_lightSource.setPos(xs, ys)

        for item in self.m_items:
            effect = item.graphicsEffect()

            delta = QPointF(item.x() - xs, item.y() - ys)
            effect.setOffset(QPointF(delta.toPoint() / 30))

            dd = math.hypot(delta.x(), delta.y())
            color = effect.color()
            color.setAlphaF(max(0.4, min(1 - dd / 200.0, 0.7)))
            effect.setColor(color)

        self.m_scene.update() 

def __init__(self):
        super(StickMan, self).__init__()

        self.m_sticks = True
        self.m_isDead = False
        self.m_pixmap = QPixmap('images/head.png')
        self.m_penColor = QColor(Qt.white)
        self.m_fillColor = QColor(Qt.black)

        # Set up start position of limbs.
        self.m_nodes = []
        for x, y in Coords:
            node = Node(QPointF(x, y), self)
            node.positionChanged.connect(self.childPositionChanged)
            self.m_nodes.append(node)

        self.m_perfectBoneLengths = []
        for n1, n2 in Bones:
            node1 = self.m_nodes[n1]
            node2 = self.m_nodes[n2]

            dist = node1.pos() - node2.pos()
            self.m_perfectBoneLengths.append(math.hypot(dist.x(), dist.y()))

        self.startTimer(10) 

def stabilize(self):
        threshold = 0.001

        for i, (n1, n2) in enumerate(Bones):
            node1 = self.m_nodes[n1]
            node2 = self.m_nodes[n2]

            pos1 = node1.pos()
            pos2 = node2.pos()

            dist = pos1 - pos2
            length = math.hypot(dist.x(), dist.y())
            diff = (length - self.m_perfectBoneLengths[i]) / length

            p = dist * (0.5 * diff)
            if p.x() > threshold and p.y() > threshold:
                pos1 -= p
                pos2 += p

                node1.setPos(pos1)
                node2.setPos(pos2) 

def __init__(self, initial_velocity, firing_angle, time_step, velocity_of_wind, angle_of_wind):
        self.x = [0]
        self.y = [0]
        self.theta = firing_angle
        self.alpha = angle_of_wind
        self.v_x = [initial_velocity * math.cos(self.theta / 180 * math.pi)]
        self.v_y = [initial_velocity * math.sin(self.theta / 180 * math.pi)]
        self.v0 = initial_velocity
        self.v = initial_velocity
        self.v_w = velocity_of_wind
        self.v_w_x = self.v_w * math.cos(self.alpha / 180 * math.pi)
        self.v_w_y = self.v_w * math.sin(self.alpha / 180 * math.pi)
        self.v_rel_x = self.v_x[0] - self.v_w_x
        self.v_rel_y = self.v_y[0] - self.v_w_y
        self.v_rel_module = math.hypot(self.v_rel_x, self.v_rel_y)
        self.C = 0
        self.B_2 = 0
        self.g = 9.8
        self.dt = time_step 

def calculate(self):
        i = 0
        while(True):
            self.B_2 = 0.0039 + 0.0058 / (1 + math.exp((self.v - 35) / 5))
            self.C = math.pow(1 - 0.0065 * self.y[i] / 273, 2.5)
            self.x.append(self.x[i] + self.v_x[i] * self.dt)
            self.y.append(self.y[i] + self.v_y[i] * self.dt)
            self.v_x.append(self.v_x[i] - self.C * self.B_2 * self.v_rel_module * self.v_rel_x * self.dt)
            self.v_y.append(self.v_y[i] - self.g * self.dt - self.C * self.B_2 * self.v_rel_module * self.v_rel_y * self.dt)
            self.v = math.hypot(self.v_x[i + 1], self.v_y[i + 1])
            self.v_rel_x = self.v_x[i + 1] - self.v_w_x
            self.v_rel_y = self.v_y[i + 1] - self.v_w_y
            self.v_rel_module = math.hypot(self.v_rel_x, self.v_rel_y)
            i += 1
            if self.y[i] <= -100:
                break
        self.x[-1]=((-100 - self.y[-1])*(self.x[-1] - self.x[-2]) / (self.y[-1] - self.y[-2])) + self.x[-1]
        self.y[i] = -100
        global a
        a = self.x[-1] 

def calculate(self):
        i = 0
        while(True):
            self.C = 4E-2 * math.pow(1 - 6.5 * self.y[i] / 300, 2.5)
            self.g.append(self.G * self.M_E / (self.R_E + self.y[i]) ** 2)
            self.x.append(self.x[i] + self.v_x[i] * self.dt)
            self.y.append(self.y[i] + self.v_y[i] * self.dt)
            self.v_x.append(self.v_x[i] - self.C * math.hypot(self.v_x[i], self.v_y[i]) * self.v_x[i] * self.dt)
            self.v_y.append(self.v_y[i] - self.g[i-1] * self.dt - self.C * math.hypot(self.v_x[i], self.v_y[i]) * self.v_y[i] * self.dt)
            i += 1
            if self.y[i] < 0:
                break
#For the falling point
        self.x[i] = - self.y[i-1] * (self.x[i] - self.x[i-1]) / (self.y[i] - self.y[i-1]) + self.x[i-1]
        self.y[i] = 0

#Maxmize the range and find the corresponding firing angle 

def __init__(self, dot_widget, target_x, target_y):
        MoveToAnimation.__init__(self, dot_widget, target_x, target_y)
        self.source_zoom = dot_widget.zoom_ratio
        self.target_zoom = self.source_zoom
        self.extra_zoom = 0

        middle_zoom = 0.5 * (self.source_zoom + self.target_zoom)

        distance = math.hypot(self.source_x - self.target_x,
                              self.source_y - self.target_y)
        rect = self.dot_widget.get_allocation()
        visible = min(rect.width, rect.height) / self.dot_widget.zoom_ratio
        visible *= 0.9
        if distance > 0:
            desired_middle_zoom = visible / distance
            self.extra_zoom = min(0, 4 * (desired_middle_zoom - middle_zoom)) 

def __init__(self, dot_widget, target_x, target_y):
        MoveToAnimation.__init__(self, dot_widget, target_x, target_y)
        self.source_zoom = dot_widget.zoom_ratio
        self.target_zoom = self.source_zoom
        self.extra_zoom = 0

        middle_zoom = 0.5 * (self.source_zoom + self.target_zoom)

        distance = math.hypot(self.source_x - self.target_x,
                              self.source_y - self.target_y)
        rect = self.dot_widget.get_allocation()
        visible = min(rect.width, rect.height) / self.dot_widget.zoom_ratio
        visible *= 0.9
        if distance > 0:
            desired_middle_zoom = visible / distance
            self.extra_zoom = min(0, 4 * (desired_middle_zoom - middle_zoom)) 

def stabilize(self):
        threshold = 0.001

        for i, (n1, n2) in enumerate(Bones):
            node1 = self.m_nodes[n1]
            node2 = self.m_nodes[n2]

            pos1 = node1.pos()
            pos2 = node2.pos()

            dist = pos1 - pos2
            length = math.hypot(dist.x(), dist.y())
            diff = (length - self.m_perfectBoneLengths[i]) / length

            p = dist * (0.5 * diff)
            if p.x() > threshold and p.y() > threshold:
                pos1 -= p
                pos2 += p

                node1.setPos(pos1)
                node2.setPos(pos2) 

def _log(z):
    abs_x = abs(z.real)
    abs_y = abs(z.imag)

    if abs_x > _LARGE_INT or abs_y > _LARGE_INT:
        return complex(math.log(math.hypot(abs_x/2, abs_y/2)) + _LOG_2,
                       math.atan2(z.imag, z.real))
    if abs_x < _DBL_MIN and abs_y < _DBL_MIN:
        if abs_x > 0 or abs_y > 0:
            return complex(math.log(math.hypot(math.ldexp(abs_x, _DBL_MANT_DIG),
                                    math.ldexp(abs_y, _DBL_MANT_DIG)))
                           - _DBL_MANT_DIG * _LOG_2,
                           math.atan2(z.imag, z.real))
        raise ValueError

    rad, phi = polar(z)
    return complex(math.log(rad), phi) 

def __init__(self,x1,y1,x2,y2,x3,y3,sector,endpoint):
    self.x_m=x1; self.x=x2; self.x_p=x3; self.y_m=y1; self.y=y2; self.y_p=y3;
    self.length_m = math.hypot(self.x_m-self.x, self.y_m-self.y)
    self.length_p = math.hypot(self.x_p-self.x, self.y_p-self.y)
    self.length_secant = math.hypot(self.x_p-self.x_m, self.y_p-self.y_m)
    self.length = (self.length_m+self.length_p)/2
    self.sector = sector;

    if endpoint:
      self.curvature = 0
    else:
      p = (self.length_m+self.length_p+self.length_secant)/2
      #print(p, self.length_m, self.length_p, self.length_secant)
      try:
        area = math.sqrt(p*(p-self.length_m)*(p-self.length_p)*(p-self.length_secant))
      except ValueError:
        area=0

      self.curvature = 4*area/(self.length_m*self.length_p*self.length_secant) 

def __init__(self, dot_widget, target_x, target_y):
        MoveToAnimation.__init__(self, dot_widget, target_x, target_y)
        self.source_zoom = dot_widget.zoom_ratio
        self.target_zoom = self.source_zoom
        self.extra_zoom = 0

        middle_zoom = 0.5 * (self.source_zoom + self.target_zoom)

        distance = math.hypot(self.source_x - self.target_x,
                              self.source_y - self.target_y)
        rect = self.dot_widget.get_allocation()
        visible = min(rect.width, rect.height) / self.dot_widget.zoom_ratio
        visible *= 0.9
        if distance > 0:
            desired_middle_zoom = visible / distance
            self.extra_zoom = min(0, 4 * (desired_middle_zoom - middle_zoom)) 

def CursorClosestTo(verts, allowedError = 0.025):
    ratioX, ratioY = ImageRatio()
    
    #any length that is certantly not smaller than distance of the closest
    min = 1000
    minV = verts[0]
    for v in verts:
        if v is None: continue
        for area in bpy.context.screen.areas:
            if area.type == 'IMAGE_EDITOR':
                loc = area.spaces[0].cursor_location
                hyp = hypot(loc.x/ratioX -v.uv.x, loc.y/ratioY -v.uv.y)
                if (hyp < min):
                    min = hyp
                    minV = v
    
    if min is not 1000: return minV
    return None 

def __init__(self, dot_widget, target_x, target_y):
        MoveToAnimation.__init__(self, dot_widget, target_x, target_y)
        self.source_zoom = dot_widget.zoom_ratio
        self.target_zoom = self.source_zoom
        self.extra_zoom = 0

        middle_zoom = 0.5 * (self.source_zoom + self.target_zoom)

        distance = math.hypot(self.source_x - self.target_x,
                              self.source_y - self.target_y)
        rect = self.dot_widget.get_allocation()
        visible = min(rect.width, rect.height) / self.dot_widget.zoom_ratio
        visible *= 0.9
        if distance > 0:
            desired_middle_zoom = visible / distance
            self.extra_zoom = min(0, 4 * (desired_middle_zoom - middle_zoom)) 

def setup_xy(self, p1_world, p2_world, p1_ucs, p2_ucs):
        """ setup an UCS given by the points p1 and p2
        only xy-plane,  z' = z
        """
        ucs_angle_to_x_axis = get_angle(p1_ucs, p2_ucs)
        world_angle_to_x_axis = get_angle(p1_world, p2_world)
        rotation = normalize_angle(world_angle_to_x_axis - ucs_angle_to_x_axis)
        self._xaxis = (math.cos(rotation), math.sin(rotation), 0.)
        self._yaxis = (math.cos(rotation + HALF_PI), math.sin(rotation + HALF_PI), 0.)
        self._zaxis = (0., 0., 1.)

        ucs_angle_to_x_axis = get_angle((0., 0.), p1_ucs)
        world_angle_to_x_axis = rotation + ucs_angle_to_x_axis
        distance_from_ucs_origin = math.hypot(p1_ucs[0], p1_ucs[1])
        delta_x = distance_from_ucs_origin * math.cos(world_angle_to_x_axis)
        delta_y = distance_from_ucs_origin * math.sin(world_angle_to_x_axis)
        self._origin = (p1_world[0] - delta_x, p1_world[1] - delta_y, 0.) 

def CursorClosestTo(verts, allowedError = 0.025):
    ratioX, ratioY = ImageRatio()
    
    #any length that is certantly not smaller than distance of the closest
    min = 1000
    minV = verts[0]
    for v in verts:
        if v is None: continue
        for area in bpy.context.screen.areas:
            if area.type == 'IMAGE_EDITOR':
                loc = area.spaces[0].cursor_location
                hyp = hypot(loc.x/ratioX -v.uv.x, loc.y/ratioY -v.uv.y)
                if (hyp < min):
                    min = hyp
                    minV = v
    
    if min is not 1000: return minV
    return None 

def placeLeak(self, leak):
        tooClose = True
        attempts = 0
        while tooClose and attempts < self._MAX_TRIES:
            attempts += 1
            locator = self.locators[random.randint(0, len(self.locators) - 1)]
            relative = self.getRelativePoint(self.board, Point3(locator.getX(), 0, locator.getZ()))
            x = relative.getX()
            z = relative.getZ()
            tooClose = False
            for otherLeak in self.activeLeaks:
                dist = math.hypot(otherLeak.getX() - x, otherLeak.getZ() - z)
                if dist < self._MIN_DIST:
                    tooClose = True
                    continue
            
            for otherLeak in self.patchedLeaks:
                dist = math.hypot(otherLeak.getX() - x, otherLeak.getZ() - z)
                if dist < self._MIN_DIST:
                    tooClose = True
                    continue
            
        leak.repositionTo(x, z) 

def diversity(first_front, first, last):
    """Given a Pareto front `first_front` and the two extreme points of the 
    optimal Pareto front, this function returns a metric of the diversity 
    of the front as explained in the original NSGA-II article by K. Deb.
    The smaller the value is, the better the front is.
    """
    df = hypot(first_front[0].fitness.values[0] - first[0],
               first_front[0].fitness.values[1] - first[1])
    dl = hypot(first_front[-1].fitness.values[0] - last[0],
               first_front[-1].fitness.values[1] - last[1])
    dt = [hypot(first.fitness.values[0] - second.fitness.values[0],
                first.fitness.values[1] - second.fitness.values[1])
          for first, second in zip(first_front[:-1], first_front[1:])]

    if len(first_front) == 1:
        return df + dl

    dm = sum(dt)/len(dt)
    di = sum(abs(d_i - dm) for d_i in dt)
    delta = (df + dl + di)/(df + dl + len(dt) * dm )
    return delta 

def find_retreat_positions(self):

        total_num_position = 1
        retreat_positions = []
        current_segment = -1
        offset_distance = 1

        current_retrace_length = 0

        while offset_distance < total_num_position + 1:
            length = math.hypot(self.computed_path[current_segment][0] - self.computed_path[current_segment - 1][0],
                                self.computed_path[current_segment][1] - self.computed_path[current_segment - 1][1])

            while offset_distance < current_retrace_length + length and offset_distance < total_num_position + 1:
                proportion = (offset_distance - current_retrace_length) / length
                new_position = list(self.computed_path[current_segment]
                                    + (np.array(self.computed_path[current_segment - 1])
                                       - self.computed_path[current_segment]) * proportion)

                retreat_positions.append(new_position)
                offset_distance += 1

            current_retrace_length += length

        return retreat_positions 

def test_hypo(points):
    dfz = Defuzzer(ndigits=0)
    dfz_points = [dfz.defuzz(pt) for pt in points]

    # The output values should all be in the inputs.
    assert all(pt in points for pt in dfz_points)

    # No two unequal output values should be too close together.
    if len(points) > 1:
        for a, b in all_pairs(dfz_points):
            if a == b:
                continue
            distance = math.hypot(a[0] - b[0], a[1] - b[1])
            assert distance > .5 

def distance(self, other):
        """Compute the distance from this Point to another Point."""
        assert isinstance(other, Point)
        x1, y1 = self
        x2, y2 = other
        return math.hypot(x2 - x1, y2 - y1) 

def offset(self, distance):
        """Create another Line `distance` from this one."""
        (x1, y1), (x2, y2) = self
        dx = x2 - x1
        dy = y2 - y1
        hyp = math.hypot(dx, dy)
        offx = dy / hyp * distance
        offy = -dx / hyp * distance
        return Line(Point(x1 + offx, y1 + offy), Point(x2 + offx, y2 + offy)) 

def __abs__(self):  # ??
        return math.hypot(self.x, self.y) 

def __abs__(self):  # ??
        return math.hypot(self.x, self.y) 

def __abs__(self):  # ??
        return math.hypot(self.x, self.y) 

def _distance(p0, p1):
	return math.hypot(p0[0] - p1[0], p0[1] - p1[1]) 

def dist(cls, p1, p2):
        (x1, y1), (x2, y2) = p1, p2
        return math.hypot(x1 - x2, y1 - y2) 

def __init__(self, start, point=None, vector=None):
        "Create a line or line segment"
        self.pos = start
        if point:
            ux = point[0] - start[0]
            uy = point[1] - start[1]
        elif type(vector) in (int, float):
            ux = 1
            uy = vector
        else: ux, uy = vector
        self._size = abs(ux), abs(uy)
        u = hypot(ux, uy)
        self.length = u #if point else None
        self.u = ux / u, uy / u 

def ondraw(self):

        # Calculate electric force
        sk = self.sketch
        dr = delta(self.pos, sk["blue"].pos)
        r = hypot(*dr) / sk.scale / 100
        F = delta(dr, mag = 8.99e-3 * sk.q1 * sk.q2 / (r * r))

        # Add electric plus gravitational forces 
        F = F[0], F[1] + sk.mass * 9.81e-3

        # Tangential acceleration
        s = sk["string"]
        u = s.u
        t = 1 / sk.frameRate
        F = (F[0] * u[1] - F[1] * u[0]) / (sk.mass / 1000) * (sk.scale / 100) / t ** 2
        ax, ay = F * u[1], -F * u[0]

        # Kinematics
        v1x, v1y = tuple(0.95 * v for v in self.vel)
        v2x = v1x + ax * t
        v2y = v1y + ay * t
        self.vel = v2x, v2y
        x, y = self.pos
        x += (v1x + v2x) * t / 2
        y += (v1y + v2y) * t / 2
        x, y = delta((x,y), s.pos, 20 * sk.scale)
        self.pos = s.pos[0] + x, s.pos[1] + y
        s.__init__(s.pos, self.pos)

        # Protractor
        if s.u[1] > 0:
            a = round(2 * degrees(asin(s.u[0]))) / 2
            a = "Angle = {:.1f}° ".format(abs(a))
        else: a = "Angle = ? "
        sk["angle"].config(data=a) 

def checkFront(self):
        "Update the front color sensor"

        # Get sensor position
        pos = delta(self.pos, vec2d(-self.radius, self.angle))

        # Sensor distance to edge of sketch
        sk = self.sketch
        if sk.weight:
            obj = sk
            prox = _distToWall(pos, self.angle, self.sensorWidth, *sk.size)
        else: obj = prox = None

        # Find closest object within sensor width
        u = vec2d(1, self.angle)
        sw = self.sensorWidth * DEG
        for gr in self.sensorObjects(sk):
            if gr is not self and gr.avgColor and hasattr(gr, "rect"):
                dr = delta(gr.rect.center, pos)
                d = hypot(*dr)
                r = gr.radius
                if r >= d:
                    prox = 0
                    obj = gr
                elif prox is None or d - r < prox:
                    minDot = cos(min(sw + asin(r/d), pi / 2))
                    x = (1 - sprod(u, dr) / d) / (1 - minDot)
                    if x < 1:
                        obj = gr
                        prox = (d - r) * (1 - x) + x * sqrt(d*d-r*r)

        # Save data
        self.closestObject = obj
        c = rgba(sk.border if obj is sk
            else obj.avgColor if obj else (0,0,0))
        self.sensorFront = noise(divAlpha(c), self.sensorNoise, 255)
        self.proximity = None if prox is None else round(prox) 

def dist(p1, p2):
    "Distance between two points"
    return hypot(p2[0] - p1[0], p2[1] - p1[1]) 

def polar2d(vx, vy, deg=True):
    "2D Cartesian to Polar conversion"
    a = atan2(vy, vx)
    return hypot(vx, vy), (a / DEG if deg else a) 

def elasticCircles(mass1, mass2):
    "Set final velocities for an elastic collision between two circles"

    # Calculate the normal vector at contact point
    x1, y1 = mass1.rect.center
    x2, y2 = mass2.rect.center
    nx = x2 - x1
    ny = y2 - y1
    r = hypot(nx, ny)
    if r >= mass1.radius + mass2.radius or r == 0:
        return # No contact!
    nx /= r
    ny /= r

    # Calculate initial momenta
    m1 = mass1.mass
    m2 = mass2.mass
    v1x, v1y = mass1.vel
    v2x, v2y = mass2.vel
    p1x = m1 * v1x
    p1y = m1 * v1y
    p2x = m2 * v2x
    p2y = m2 * v2y

    # Calculate impulse and final velocities
    impulse = 2 * (m2 * (p1x * nx + p1y * ny) - m1 * (p2x * nx + p2y * ny)) / (m1 + m2)
    if impulse > 0:
        mass1.vel = (p1x - impulse * nx) / m1, (p1y - impulse * ny) / m1
        mass2.vel = (p2x + impulse * nx) / m2, (p2y + impulse * ny) / m2
        return True 

def __abs__(self):
        'Return the vector\'s magnitude.'
        return _math.hypot(self.x, self.y)