Return the X-position of the end point of this connector, in English
        Metric Units (as a |Length| object).
345462
def end_x(self):
        
        cxnSp = self._element
        x, cx, flipH = cxnSp.x, cxnSp.cx, cxnSp.flipH
        end_x = x if flipH else x+cx
        return Emu(end_x)
380007
def _move_end_to_cxn(self, shape, cxn_pt_idx):
        
        x, y, cx, cy = shape.left, shape.top, shape.width, shape.height
        self.end_x, self.end_y = {
            0: (int(x + cx/2), y),
            1: (x, int(y + cy/2)),
            2: (int(x + cx/2), y + cy),
            3: (x + cx, int(y + cy/2)),
        }[cxn_pt_idx]
611013
def into_signalfx_point(self, metric):
        
        dims = {
            "collector": metric.getCollectorPath(),
            "prefix": metric.getPathPrefix(),
        }
        if metric.host is not None and metric.host != "":
            dims["host"] = metric.host

        return {
            "metric": metric.getMetricPath(),
            "value": metric.value,
            "dimensions": dims,
            # We expect ms timestamps
            "timestamp": metric.timestamp * 1000,
        }
153500
def get_website_endpoint(self):
        
        l = [self.name]
        l.append(S3WebsiteEndpointTranslate.translate_region(self.get_location()))
        l.append('.'.join(self.connection.host.split('.')[-2:]))
        return '.'.join(l)
43722
def getPositionAndSize(self):
        '''
        
        '''

        (x, y) = self.getXY();
        w = self.getWidth()
        h = self.getHeight()
        return (x, y, w, h)
1015256
protected Result<float[]> getEdgeMidPoint(long from, long to) {
        Result<PortalResult> ppoints = getPortalPoints(from, to);
        if (ppoints.failed()) {
            return Result.of(ppoints.status, ppoints.message);
        }
        float[] left = ppoints.result.left;
        float[] right = ppoints.result.right;
        float[] mid = new float[3];
        mid[0] = (left[0] + right[0]) * 0.5f;
        mid[1] = (left[1] + right[1]) * 0.5f;
        mid[2] = (left[2] + right[2]) * 0.5f;
        return Result.success(mid);
    }
1237817
def point(self, t):
        """"""
        distance = self.end - self.start
        return self.start + distance*t
666082
def getBottomRight(self):
        
        return (float(self.get_x()) + float(self.get_width()), float(self.get_y()))
227743
def _get_x_axis(self):
        """"""
        # 0,0 is top/left top top/left pixel. Actual x/y coord of that pixel are (.5,.5).
        x_centers = np.linspace(.5, self.x_size - .5, self.x_size)
        y_centers = x_centers * 0
        return (self.geotransform[0]
                + self.geotransform[1] * x_centers
                + self.geotransform[2] * y_centers)
1162418
def _locate(self, idx):
        
        start = idx * self._width
        end = (idx + 1) * self._width
        sbyte, sbit = divmod(start, 8)
        ebyte = BinInt(end).ceildiv(8)
        return sbyte, sbit, ebyte
954732
def ends(self, s):
        length = len(s)
        
        res = (self.b[self.k-length+1:self.k+1] == s)
        if res:
            self.j = self.k - length
        return res
296393
def getTopLeft(self):
        
        return (float(self.get_x()), float(self.get_y())+ float(self.get_height()))
179485
def _position():
    

    cursor = POINT()
    ctypes.windll.user32.GetCursorPos(ctypes.byref(cursor))
    return (cursor.x, cursor.y)
311546
def getCollectorPath(self):
        
        # If we don't have a host name, assume it's just the third part of the
        # metric path
        if self.host is None:
            return self.path.split('.')[2]

        offset = self.path.index(self.host)
        offset += len(self.host) + 1
        endoffset = self.path.index('.', offset)
        return self.path[offset:endoffset]
754440
def endpoint(distance, heading)
      d = (distance / 1000.0) / EARTH_RADIUS_KM;
      heading = deg2rad(heading);

      oX = lng * Math::PI / 180;
      oY = lat * Math::PI / 180;

      y = Math.asin(Math.sin(oY) * Math.cos(d) + Math.cos(oY) * Math.sin(d) * Math.cos(heading));
      x = oX + Math.atan2(Math.sin(heading) * Math.sin(d) * Math.cos(oY), Math.cos(d) - Math.sin(oY) * Math.sin(y));

      y = y * 180 / Math::PI;
      x = x * 180 / Math::PI;

      self.class.new(:lat => y, :lng => x)
    end
665545
def D(self):
        '''
        
        '''
        return Point(self.minX, self.maxY, self.origin.z)
939334
def endpoint(cls):
        
        endpoint = ''
        if cls.__endpoint__ is not None:
            return cls.__endpoint__
        elif cls.__from_class__ is not None:
            endpoint = cls.__from_class__.__name__.lower()
        else:
            endpoint = cls.__tablename__.lower()
        if not endpoint.endswith('s'):
            endpoint += 's'
        return endpoint