def select_by_rois_proximity(self, timeseries, proximity, proximity_th=None):
initial_selection = range(timeseries.number_of_labels)
selection = []
for prox in proximity:
selection += (
np.array(initial_selection)[select_greater_values_array_inds(prox, proximity_th)]).tolist()
return timeseries.get_subspace_by_index(np.unique(selection).tolist())
def update_active_regions_seeg(self,
target_data,
probabilistic_model,
sensors,
reset=False):
if reset:
probabilistic_model.update_active_regions([])
if target_data:
active_regions = probabilistic_model.active_regions
gain_matrix = np.array(sensors.gain_matrix)
seeg_inds = sensors.get_sensors_inds_by_sensors_labels(
target_data.space_labels)
if len(seeg_inds) != 0:
gain_matrix = gain_matrix[seeg_inds]
for proj in gain_matrix:
active_regions += select_greater_values_array_inds(
proj).tolist()
probabilistic_model.update_active_regions(active_regions)
else:
warning(
"Skipping active regions setting by seeg power because no data were assigned to sensors!"
)
else:
warning(
"Skipping active regions setting by seeg power because no target data were provided!"
)
return probabilistic_model
def compute_nearest_regions_to_sensors(self, head, sensors=None, target_contacts=None, s_type=Sensors.TYPE_SEEG,
sensors_id=0, n_regions=None, gain_matrix_th=None):
if not (isinstance(sensors, Sensors)):
sensors = head.get_sensors_id(s_type=s_type, sensor_ids=sensors_id)
n_contacts = sensors.labels.shape[0]
if isinstance(target_contacts, (list, tuple, np.ndarray)):
target_contacts = ensure_list(target_contacts)
for itc, tc in enumerate(target_contacts):
if isinstance(tc, int):
continue
elif isinstance(tc, basestring):
target_contacts[itc] = sensors.contact_label_to_index([tc])
else:
raise_value_error("target_contacts[" + str(itc) + "] = " + str(tc) +
"is neither an integer nor a string!")
else:
target_contacts = range(n_contacts)
auto_flag = False
if n_regions is "all":
n_regions = head.connectivity.number_of_regions
elif not (isinstance(n_regions, int)):
auto_flag = True
nearest_regions = []
for tc in target_contacts:
projs = sensors.gain_matrix[tc]
inds = np.argsort(projs)[::-1]
if auto_flag:
n_regions = select_greater_values_array_inds(projs[inds], threshold=gain_matrix_th)
inds = inds[:n_regions]
nearest_regions.append((inds, head.connectivity.region_labels[inds], projs[inds]))
return nearest_regions
def select_signals_seeg(self, signals, rois, auto_selection, **kwargs):
sensors = Sensors(self.sensors_labels, self.sensors_locations, gain_matrix=self.gain_matrix)
inds = range(signals.shape[1])
head_service = HeadService()
if auto_selection.find("rois") >= 0:
if sensors.gain_matrix is not None:
current_selection = head_service.select_sensors_rois(sensors, kwargs.get("rois", rois),
self.signals_inds,
kwargs.get("gain_matrix_th", None))
inds = np.where([s in current_selection for s in self.signals_inds])[0]
self.signals_inds = np.array(self.signals_inds)[inds].tolist()
signals = signals[:, inds]
if auto_selection.find("correlation-power") >= 0:
power = kwargs.get("power", np.sum((signals - np.mean(signals, axis=0)) ** 2, axis=0) / signals.shape[0])
correlation = kwargs.get("correlation", np.corrcoef(signals.T))
current_selection = head_service.select_sensors_corr(sensors, correlation, self.signals_inds, power=power,
n_electrodes=kwargs.get("n_electrodes"),
sensors_per_electrode=kwargs.get(
"sensors_per_electrode", 1),
group_electrodes=kwargs.get("group_electrodes", True))
inds = np.where([s in current_selection for s in self.signals_inds])[0]
self.signals_inds = np.array(self.signals_inds)[inds].tolist()
elif auto_selection.find("power"):
power = kwargs.get("power", np.sum(signals ** 2, axis=0) / signals.shape[0])
inds = select_greater_values_array_inds(power, kwargs.get("power_th", None))
self.signals_inds = (np.array(self.signals_inds)[inds]).tolist()
self.n_signals = len(self.signals_inds)
return signals[:, inds]
def update_active_regions_x0_values(self, statistical_model, active_regions_th=0.1, reset=False):
if reset:
statistical_model.update_active_regions([])
statistical_model.update_active_regions(statistical_model.active_regions +
select_greater_values_array_inds(self.x0_values,
active_regions_th).tolist())
return statistical_model
def select_sensors_rois(self, sensors, rois=None, initial_selection=[], gain_matrix_th=0.5):
if len(initial_selection) == 0:
initial_selection = range(sensors.number_of_sensors)
selection = []
if sensors.gain_matrix is None:
raise_value_error("Projection matrix is not set!")
else:
for proj in sensors.gain_matrix[initial_selection].T[rois]:
selection += (
np.array(initial_selection)[select_greater_values_array_inds(proj, gain_matrix_th)]).tolist()
return np.unique(selection).tolist()
def update_active_regions_lsa(self, statistical_model, active_regions_th=None, reset=False):
if reset:
statistical_model.update_active_regions([])
if len(self.lsa_propagation_strengths) > 0:
ps_strengths = self.lsa_propagation_strengths / np.max(self.lsa_propagation_strengths)
statistical_model.update_active_regions(statistical_model.active_regions +
select_greater_values_array_inds(ps_strengths,
active_regions_th).tolist())
else:
self.logger.warning("No LSA results found (empty propagations_strengths vector)!" +
"\nSkipping of setting active_regios according to LSA!")
return statistical_model
def select_signals_lfp(self, signals, rois, auto_selection, **kwargs):
if auto_selection.find("rois") >= 0:
if kwargs.get("rois", rois):
inds = np.where([s in rois for s in self.signals_inds])[0]
signals = signals[:, inds]
self.signals_inds = np.array(self.signals_inds)[inds].tolist()
if auto_selection.find("power") >= 0:
power = kwargs.get("power", np.sum((signals - np.mean(signals, axis=0)) ** 2, axis=0) / signals.shape[0])
inds = select_greater_values_array_inds(power, kwargs.get("power_th", None))
signals = signals[:, inds]
self.signals_inds = (np.array(self.signals_inds)[inds]).tolist()
self.n_signals = len(self.signals_inds)
return signals
def update_active_regions_x0_values(self,
probabilistic_model,
x0_values,
reset=False):
if reset:
probabilistic_model.update_active_regions([])
if len(x0_values) > 0:
probabilistic_model.update_active_regions(
probabilistic_model.active_regions +
select_greater_values_array_inds(x0_values,
self.active_x0_th).tolist())
else:
warning(
"Skipping active regions setting by x0 values because no such values were provided!"
)
return probabilistic_model
def update_active_regions_lsa(self,
probabilistic_model,
lsa_propagation_strengths,
reset=False):
if reset:
probabilistic_model.update_active_regions([])
if len(lsa_propagation_strengths) > 0:
ps_strengths = lsa_propagation_strengths / np.max(
lsa_propagation_strengths)
probabilistic_model.update_active_regions(
probabilistic_model.active_regions +
select_greater_values_array_inds(ps_strengths,
self.active_lsa_th).tolist())
else:
self.logger.warning(
"No LSA results found (empty propagations_strengths vector)!" +
"\nSkipping of setting active regions according to LSA!")
return probabilistic_model
def update_active_regions_seeg(self, statistical_model, active_regions_th=None, seeg_inds=[], reset=False):
if reset:
statistical_model.update_active_regions([])
if self.gain_matrix is not None:
active_regions = statistical_model.active_regions
if len(seeg_inds) == 0:
seeg_inds = self.signals_inds
if len(seeg_inds) != 0:
gain_matrix = self.gain_matrix[seeg_inds]
else:
gain_matrix = self.gain_matrix
for proj in gain_matrix:
active_regions += select_greater_values_array_inds(proj, active_regions_th).tolist()
statistical_model.update_active_regions(active_regions)
else:
self.logger.warning(
"Projection is not found!" + "\nSkipping of setting active_regios according to SEEG power!")
return statistical_model
def select_by_metric(self, timeseries, metric, metric_th=None):
return timeseries.get_subspace_by_index(select_greater_values_array_inds(metric, metric_th))
def select_sensors_power(self, sensors, power, selection=[], power_th=0.5):
if len(selection) == 0:
selection = range(sensors.number_of_sensors)
return (np.array(selection)[select_greater_values_array_inds(power, power_th)]).tolist()
