Relabels all Atoms in numerical order, offset by the start parameter.

        Parameters
        ----------
        start : int, optional
            Defines an offset for the labelling.
7878
def relabel_atoms(self, start=1):
        
        counter = start
        for atom in self.get_atoms(ligands=True):
            atom.id = counter
            counter += 1
        return
785608
def move_to_start(self, column_label):
        """"""
        self._columns.move_to_end(column_label, last=False)
        return self
780727
public static void relabel(GrayS32 input , int labels[] ) {
		if( BoofConcurrency.USE_CONCURRENT ) {
			ImplBinaryImageOps_MT.relabel(input, labels);
		} else {
			ImplBinaryImageOps.relabel(input, labels);
		}
	}
977283
def resp_set_label(self, resp, label=None):
        
        if label:
            self.label=label
        elif resp:
            self.label=resp.label.decode().replace("\x00", "")
211034
private void resetRoundRobin(String preferredNodeIdPrefix) {
        DisqueNode previous = null; // remember the previous node because the offset is a marker to start with the next
        // element
        for (DisqueNode disqueNode : getNodes()) {
            if (disqueNode.getNodeId().startsWith(preferredNodeIdPrefix)) {
                roundRobin = new RoundRobin<DisqueNode>(getNodes(), previous);
                return;
            }
            previous = disqueNode;
        }
    }
316238
def _append_to_label(self, element):
        
        if len(self.address_label) > 0\
                and self._is_exception_rule(self.address_label[-1]):
            self.address_label[-1] += (' ' + element)
        else:
            self.address_label.append(element)
470963
protected void alignStart(Calendar start) {
		start.set(Calendar.HOUR_OF_DAY,1);
		start.set(Calendar.MINUTE,1);
		start.set(Calendar.SECOND,1);
	}
1309217
def position_changed(position)
      instruction = position.object
      return unless instruction.is_a?(Label)
      instruction.address.set_value(position.at)
    end
1010481
def set_label(self, label, lineno, local=False):
        
        ex_label, namespace = Memory.id_name(label)

        if ex_label in self.local_labels[-1].keys():
            result = self.local_labels[-1][ex_label]
            result.lineno = lineno
        else:
            result = self.local_labels[-1][ex_label] = Label(ex_label, lineno, namespace=NAMESPACE)

        if result.local == local:
            warning(lineno, "label '%s' already declared as LOCAL" % label)

        result.local = local

        return result
590690
def setOrderedRegisterNumbers(order, start):
    
    for i, node in enumerate(order):
        node.reg.n = start + i
    return start + len(order)
80917
def restart(self, start_from=1, occupied=[]):
        

        # initial ID
        self.top = start_from - 1

        # occupied IDs
        self._occupied = sorted(occupied, key=lambda x: x[0])

        # main dictionary storing the mapping from objects to variable IDs
        self.obj2id = collections.defaultdict(lambda: self._next())

        # mapping back from variable IDs to objects
        # (if for whatever reason necessary)
        self.id2obj = {}
1189911
public void mark(Label label) {
        adopt(label);
        if (label.marked) {
            throw new IllegalStateException("already marked");
        }
        label.marked = true;
        if (currentLabel != null) {
            jump(label); // blocks must end with a branch, return or throw
        }
        currentLabel = label;
    }
1066024
def calculate_offset(cls, labels):
        ''''''
        used_strings = set(cls._nice_strings.keys()) & set(labels)
        return max([len(cls._nice_strings[s]) for s in used_strings])
1147837
def get_objects_by_offset(self, start):
        

        _, container = self._get_container(start)
        if container is None:
            return set()
        else:
            return container.internal_objects
1199829
def relabel(image):
    
    #
    # Build a label table that converts an old label # into
    # labels using the new numbering scheme
    #
    unique_labels = np.unique(image[image!=0])
    if len(unique_labels) == 0:
        return (image,0)
    consecutive_labels = np.arange(len(unique_labels))+1
    label_table = np.zeros(unique_labels.max()+1, int)
    label_table[unique_labels] = consecutive_labels
    #
    # Use the label table to remap all of the labels
    #
    new_image = label_table[image]
    return (new_image,len(unique_labels))
498489
def label(self,x,y,label,offset=[0,0]):
        """"""
        (xc,yc)=self.p2c([x,y])
        return self.create_text(xc-offset[0],yc-offset[1],text=label)
489390
public void setStart(int x1, int y1) {
		start.x = x1;
		start.y = y1;
		needsRefresh = true;
	}