Probe attaching: do we really need a dense representation? #4553

def get_channel_locations(self, channel_ids=None, axes: str = "xy") -> np.ndarray:
    if channel_ids is None:
        channel_ids = self.get_channel_ids()
    channel_indices = self.ids_to_indices(channel_ids)
    contact_vector = self.get_property("contact_vector")
    if contact_vector is not None:
        ndim = len(axes)
        all_positions = np.zeros((contact_vector.size, ndim), dtype="float64")
        for i, dim in enumerate(axes):
            all_positions[:, i] = contact_vector[dim]
        positions = all_positions[channel_indices]
        return positions
    else:
        locations = self.get_property("location")
        if locations is None:
            raise Exception("There are no channel locations")
        locations = np.asarray(locations)[channel_indices]
        return select_axes(locations, axes)

def get_channel_locations(self, channel_ids=None, axes: str = "xy") -> np.ndarray:
    if channel_ids is None:
        channel_ids = self.get_channel_ids()
    channel_indices = self.ids_to_indices(channel_ids)
    if self.has_probe():
        contact_vector = self._probegroup._build_contact_vector()
        ndim = len(axes)
        all_positions = np.zeros((contact_vector.size, ndim), dtype="float64")
        for i, dim in enumerate(axes):
            all_positions[:, i] = contact_vector[dim]
        return all_positions[channel_indices]
    locations = self.get_property("location")
    if locations is None:
        raise Exception("There are no channel locations")
    locations = np.asarray(locations)[channel_indices]
    return select_axes(locations, axes)

# change the wiring of the probe
contact_vector = self.get_property("contact_vector")
if contact_vector is not None:
    contact_vector["device_channel_indices"] = np.arange(len(channel_ids), dtype="int64")
    self.set_property("contact_vector", contact_vector)

# inherit the probegroup by reference; the `wiring` per-channel property
# rode through copy_metadata above with the filtered channel_ids
if parent_recording.has_probe():
    self._probegroup = parent_recording._probegroup

for prop_name, prop_values in property_dict.items():
    if prop_name == "contact_vector":
        # remap device channel indices correctly
        prop_values["device_channel_indices"] = np.arange(self.get_num_channels())
    self.set_property(key=prop_name, values=prop_values)

# if locations are present, check that they are all different!
if "location" in self.get_property_keys():
    location_tuple = [tuple(loc) for loc in self.get_property("location")]
    assert len(set(location_tuple)) == self.get_num_channels(), (
        "Locations are not unique! " "Cannot aggregate recordings!"
    )

planar_contour_keys = [
    key for recording in recording_list for key in recording.get_annotation_keys() if "planar_contour" in key
]
if len(planar_contour_keys) > 0:
    if all(
        k == planar_contour_keys[0] for k in planar_contour_keys
    ):  # we add the 'planar_contour' annotations only if there is a unique one in the recording_list
        planar_contour_key = planar_contour_keys[0]
        collect_planar_contours = []
        for rec in recording_list:
            collect_planar_contours.append(rec.get_annotation(planar_contour_key))
        if all(np.array_equal(arr, collect_planar_contours[0]) for arr in collect_planar_contours):
            self.set_annotation(planar_contour_key, collect_planar_contours[0])

if all(rec.has_probe() for rec in recording_list):
    first_pg = recording_list[0]._probegroup
    if all(rec._probegroup is first_pg for rec in recording_list):
        combined_probegroup = first_pg
    else:
        combined_probegroup = ProbeGroup()
        for rec in recording_list:
            for probe in rec._probegroup.probes:
                # workaround for probeinterface #421; becomes `probe.copy()` once fixed
                probe_copy = Probe.from_dict(probe.to_dict(array_as_list=False))
                # required to pass probeinterface's cross-probe dci uniqueness check;
                # dci is a local index, the canonical wiring lives on the recording's
                # `wiring` property, so provenance is preserved
                probe_copy.set_device_channel_indices(
                    np.full(probe_copy.get_contact_count(), -1, dtype="int64")
                )
                combined_probegroup.add_probe(probe_copy)
    self._probegroup = combined_probegroup