Returns the upper points of a ramp.
170713
def upper(self) -> Set[Point2]:
        
        max_height = max([self.height_at(p) for p in self._points])
        return {p for p in self._points if self.height_at(p) == max_height}
592568
public Point getCenter() {
        Point upperLeft = this.getLocation();
        Dimension dimensions = this.getSize();
        return new Point(upperLeft.getX() + dimensions.getWidth() / 2,
            upperLeft.getY() + dimensions.getHeight() / 2);
    }
1373705
def frontage(self):
        """"""
        if self.length and self.area:
            return round(self.area / self.length)
338559
def _get_gos_upper(self, ntpltgo1, max_upper, go2parentids):
        """"""
        # Get GO IDs which are in the hdrgo path
        goids_possible = ntpltgo1.gosubdag.go2obj.keys()
        # Get upper GO IDs which have the most descendants
        return self._get_gosrcs_upper(goids_possible, max_upper, go2parentids)
307809
def getTopRight(self):
        
        return (float(self.get_cx()) + float(self.get_r()), float(self.get_cy()) + float(self.get_r()))
916287
def getLimit(self, alpha, upper=True):
        
        dlnl = onesided_cl_to_dlnl(1.0 - alpha)
        return self.getDeltaLogLike(dlnl, upper=upper)
5288
def floor(self):
    """"""
    return Point(int(math.floor(self.x)), int(math.floor(self.y)))
67935
function toPoint(p, s, d) {
      return [
        p[0] + s * d[0],
        p[1] + s * d[1]
      ];
    }
1334287
def get_maximum(self, other):
        """"""
        return Point(max(self.x, other.x), max(self.y, other.y))
712889
def B(self):
        '''
        
        '''
        return Point(self.maxX, self.minY, self.origin.z)
138568
def _get_gosrcs_upper(self, goids, max_upper, go2parentids):
        """"""
        gosrcs_upper = set()
        get_nt = self.gosubdag.go2nt.get
        go2nt = {g:get_nt(g) for g in goids}
        # Sort by descending order of descendant counts to find potential new hdrgos
        go_nt = sorted(go2nt.items(), key=lambda t: -1*t[1].dcnt)
        goids_upper = set()
        for goid, _ in go_nt: # Loop through GO ID, GO nt
            goids_upper.add(goid)
            if goid in go2parentids:
                goids_upper |= go2parentids[goid]
            #print "{} {:3} {}".format(goid, len(goids_upper), gont.GO_name)
            if len(goids_upper) < max_upper:
                gosrcs_upper.add(goid)
            else:
                break
        return gosrcs_upper
692075
def start_point(self):
        
        edge = self.result.wire().val().Edges()[0]
        return edge.Vertices()[0].Center()
859572
def max(self):
        
        return self._constructor(self.values.max(axis=self.baseaxes, keepdims=True))
792291
def get_ramp_regions(self):
        """"""
        skl = self.key_frame_list.sorted_key_list()
        ramp_or_jump = np.zeros(len(skl) - 1)
        used_key_frames = self.get_used_key_frame_list()
        for region_number, start_key in enumerate(skl[:-1]):
            if start_key in used_key_frames:
                key_data = self.dct['keys'][start_key]
                ramp_type = key_data['ramp_type']
                if ramp_type != "jump":
                    # this means that a ramp starts in this region. Figure
                    # out where it ends
                    curr_key_num = used_key_frames.index(start_key)
                    end_key_number = curr_key_num + 1
                    # figure out if the current key was the last key
                    if end_key_number < len(used_key_frames):
                        # if it wasnt, then find the end region
                        end_key_name = used_key_frames[end_key_number]
                        end_region_index = skl.index(end_key_name)
                        ramp_or_jump[region_number:end_region_index] = 1
        return ramp_or_jump
296393
def getTopLeft(self):
        
        return (float(self.get_x()), float(self.get_y())+ float(self.get_height()))
185529
def get_top_tracks(self, limit=None, cacheable=True):
        """"""
        params = self._get_params()
        if limit:
            params["limit"] = limit

        return self._get_things("getTopTracks", "track", Track, params, cacheable)
665545
def D(self):
        '''
        
        '''
        return Point(self.minX, self.maxY, self.origin.z)