Returns just the upper and lower boundaries
        [upper, lower] representing the most general positive
        boundaries and the most specific lower boundaries
183027
def get_boundaries(self):
        
        if not self.__values_computed:
            self.__compute_values()
        return set(self.upper), set(self.lower)
375295
def bottoms(panels):
    
    bottom_lines = [(p['col'], p['row'] + p['size_y'], p['col'] + p['size_x'], p['row'] + p['size_y']) for p in panels]
    return sorted(bottom_lines, key=lambda l: l[1], reverse=True)
665601
def _get_bounds_local(layers):
    
    if not layers:
        return {'west': None, 'south': None, 'east': None, 'north': None}

    bounds = layers[0].bounds

    for layer in layers[1:]:
        bounds = np.concatenate(
            (
                np.minimum(
                    bounds[:2],
                    layer.bounds[:2]
                ),
                np.maximum(
                    bounds[2:],
                    layer.bounds[2:]
                )
            )
        )

    return dict(zip(['west', 'south', 'east', 'north'], bounds))
50015
def _get_stem_upper_boundary(self, timeperiod=None):
        

        if self.time_qualifier == QUALIFIER_HOURLY:
            upper_boundary = 23
        elif self.time_qualifier == QUALIFIER_DAILY:
            if timeperiod:
                # DAILY upper boundary is month-dependent
                # i.e. it is 28 for Feb 2015; and 31 for Mar 2015
                year, month, day, hour = time_helper.tokenize_timeperiod(timeperiod)
                monthrange_tuple = calendar.monthrange(int(year), int(month))
                upper_boundary = monthrange_tuple[1]
            else:
                upper_boundary = 28
        elif self.time_qualifier == QUALIFIER_MONTHLY:
            upper_boundary = 12
        elif self.time_qualifier == QUALIFIER_YEARLY:
            upper_boundary = 1
        else:
            raise ValueError('unknown time qualifier: {0}'.format(self.time_qualifier))
        return upper_boundary
148942
protected void selectBoundaryCorners() {
		List<Point2D_F64> layout = detector.getLayout();

		Polygon2D_F64 hull = new Polygon2D_F64();
		UtilPolygons2D_F64.convexHull(layout,hull);
		UtilPolygons2D_F64.removeAlmostParallel(hull,0.02);

		boundaryIndexes = new int[hull.size()];
		for (int i = 0; i < hull.size(); i++) {
			Point2D_F64 h = hull.get(i);
			boolean matched = false;
			for (int j = 0; j < layout.size(); j++) {
				if( h.isIdentical(layout.get(j),1e-6)) {
					matched = true;
					boundaryIndexes[i] = j;
					break;
				}
			}
			if( !matched )
				throw new RuntimeException("Bug!");
		}

	}
89118
def get_edges(self):
        

        lr_x, lr_y = self.get_vec_lr()
        tb_x, tb_y = self.get_vec_tb()

        top_left = self.x, self.y
        top_right = self.x + lr_x, self.y + lr_y
        bottom_left = self.x + tb_x, self.y + tb_y
        bottom_right = self.x + lr_x + tb_x, self.y + lr_y + tb_y

        return top_left, top_right, bottom_left, bottom_right
1236058
def _get_leftMargin(self):
        
        bounds = self.bounds
        if bounds is None:
            return None
        xMin, yMin, xMax, yMax = bounds
        return xMin
303434
private int[] checkBoundaries(int[] minMax, int[] dim) {
        if (minMax[0] < 0) {
            minMax[0] = 0;
        }
        if (minMax[1] > dim[0]) {
            minMax[1] = dim[0];
        }
        if (minMax[2] < 0) {
            minMax[2] = 0;
        }
        if (minMax[3] > dim[1]) {
            minMax[3] = dim[1];
        }
        if (minMax[4] < 0) {
            minMax[4] = 0;
        }
        if (minMax[5] > dim[2]) {
            minMax[5] = dim[2];
        }
        return minMax;
    }
1129975
def boundary_map(self):
        
        # compute contours
        contours = self.find_contours()

        # fill in nonzero pixels
        new_data = np.zeros(self.data.shape)
        for contour in contours:
            new_data[contour.boundary_pixels[:, 0].astype(np.uint8),
                     contour.boundary_pixels[:, 1].astype(np.uint8)] = np.iinfo(np.uint8).max
        return BinaryImage(new_data.astype(np.uint8), frame=self.frame)
466595
public Criteria between(@Nullable Object lowerBound, @Nullable Object upperBound) {
		return between(lowerBound, upperBound, true, true);
	}
592072
def _extents(self):
        
        return (
            self._parent.width - self.margin_left - self.margin_right,
            self._parent.height - self.margin_top - self.margin_bottom
        )
925048
protected function boundaries()
	{
		if ( !is_null( $this->_boundaries ) )
			return $this->_boundaries;

		// we have defined the boundaries of two non-overlapping intervals,
		// so sorting puts both the intervals and their boundaries in order
		$this->_boundaries = [
			$this->model->getLeft(),
			$this->model->getRight(),
			$this->bound1(),
			$this->bound2()
		];
		sort( $this->_boundaries );

		return $this->_boundaries;
	}
1333663
public function between($lowerBound, $upperBound, $includeLowerBound = true, $includeUpperBound = true)
    {
        $lowerBound = ($lowerBound === null) ? '*' : $lowerBound;
        $upperBound = ($upperBound === null) ? '*' : $upperBound;
        $this->predicates[] = ($includeLowerBound ? '[' : '{') . $this->processValue($lowerBound) .
            ' TO ' . $this->processValue($upperBound) . ($includeUpperBound ? ']' : '}');

        return $this;
    }
1252388
def lowerbound(self, axis=0):
        
        if not 0 <= axis < self.GetDimension():
            raise ValueError(
                "axis must be a non-negative integer less than "
                "the dimensionality of the histogram")
        if axis == 0:
            return self.xedges(1)
        if axis == 1:
            return self.yedges(1)
        if axis == 2:
            return self.zedges(1)
        raise TypeError("axis must be an integer")
1060665
def make_bound(lower, upper, lineno):
    
    return symbols.BOUND.make_node(lower, upper, lineno)
381026
public Range<T> leftHalfOpen(T lower, T upper) {
        return new DenseRange<T>(sequencer, comparator, Endpoint.Exclude, lower, Optional.of(upper), Endpoint.Include);
    }
945100
def get_cell_boundary_map(ds):
    '''
    
    '''
    boundary_map = {}
    for variable in ds.get_variables_by_attributes(bounds=lambda x: x is not None):
        if variable.bounds in ds.variables:
            boundary_map[variable.name] = variable.bounds
    return boundary_map