def _features_parsing_creation(feats_info):
"""Features General parsing function. This function transforms any features
information into a FeaturesManager object.
Parameters
----------
feats_info: np.ndarray, list, tuple, pst.BaseFeatures, pst.FeaturesManager
The features information to create features object. The Standards
inputs accepted are:
* np.ndarray
* Features object
* FeaturesManager object
* (np.ndarray, pars_featuresManager)
* (np.ndarray, pars_featuresManager, descriptormodel)
* (Features object, pars_featuresManager)
* (Features object, pars_featuresManager, descriptormodel)
* (Features_info tuple, pars_featuresManager)
* (Features_info tuple, pars_featuresManager, descriptormodel)
Returns
-------
feats_info: pst.FeaturesManager
the features manager created by the information given in the input.
"""
if type(feats_info) == np.ndarray:
feats_info = _featuresobject_parsing_creation(feats_info)
feats_info = FeaturesManager(feats_info)
elif isinstance(feats_info, BaseFeatures):
feats_info = FeaturesManager(feats_info)
elif type(feats_info) == list:
assert all([isinstance(e, BaseFeatures) for e in feats_info])
feats_info = FeaturesManager(feats_info)
elif isinstance(feats_info, FeaturesManager):
pass
else:
assert type(feats_info) == tuple
assert type(feats_info[1]) == dict
if type(feats_info[0]) == np.ndarray:
feats_info = _featuresobject_parsing_creation(feats_info)
feats_info = FeaturesManager(feats_info)
elif isinstance(feats_info[0], BaseFeatures):
feats_info = _featuresmanager_parsing_creation(feats_info)
elif type(feats_info[0]) == list:
feats_info = _featuresmanager_parsing_creation(feats_info)
else:
assert type(feats_info[0]) == tuple
new_feats_info = _featuresobject_parsing_creation(feats_info[0])
if len(feats_info) == 2:
new_pars_info = (new_feats_info, feats_info[1])
else:
new_pars_info = (new_feats_info, feats_info[1], feats_info[2])
feats_info = _featuresmanager_parsing_creation(new_pars_info)
assert isinstance(feats_info, FeaturesManager)
return feats_info
def _format_features(self, features_objects):
"""Formatter of features.
Parameters
----------
features_objects: list or pst.BaseFeatures
the features objects in order to be managed by the manage.
"""
## 0. Format to list mode
# Format to list mode
if type(features_objects) != list:
features_objects = [features_objects]
# Format to feature objects
nfeat = len(features_objects)
for i in range(nfeat):
# features_objects[i] = self._auxformat_features(features_objects[i])
features_objects[i] = _featuresobject_parsing_creation(features_objects[i])
self.features = features_objects
## 1. Check input
if nfeat == 0:
msg = "Any feature object is input in the featureRetriever."
raise TypeError(msg)
## 2. Format kperturb
self._format_k_perturbs()
def _featuresmanager_parsing_creation(feats_info):
"""FeaturesManager instantiation from features information. This function
transforms features information into a FeaturesManager object.
Parameters
----------
feats_info: np.ndarray, list, tuple, pst.BaseFeatures, pst.FeaturesManager
The features information to create features object. The Standards
inputs accepted are:
* Features object
* FeaturesManager object
* (Features object, pars_featuresManager)
* (Features object, pars_featuresManager, descriptormodel)
Returns
-------
feats_info: pst.FeaturesManager
the features manager created by the information given in the input.
"""
if isinstance(feats_info, BaseFeatures):
feats_info = FeaturesManager(feats_info)
elif type(feats_info) == list:
assert all([isinstance(e, BaseFeatures) for e in feats_info])
feats_info = FeaturesManager(feats_info)
elif isinstance(feats_info, FeaturesManager):
pass
else:
assert type(feats_info) == tuple
if isinstance(feats_info[0], BaseFeatures) or type(feats_info[0]) == list:
if type(feats_info[0]) == list:
assert all([isinstance(e, BaseFeatures) for e in feats_info[0]])
assert type(feats_info[1]) == dict
assert len(feats_info) >= 2
if len(feats_info) == 2:
pars_features = feats_info[1]
else:
assert len(feats_info) == 3
if type(feats_info[2]) == list:
for i in range(len(feats_info[2])):
assert isinstance(feats_info[2][i], BaseDescriptorModel)
else:
assert isinstance(feats_info[2], BaseDescriptorModel)
pars_features = feats_info[1]
pars_features["descriptormodels"] = feats_info[2]
feats_info = FeaturesManager(feats_info[0], **pars_features)
else:
assert type(feats_info[0]) == tuple
new_feats_info = _featuresobject_parsing_creation(feats_info[0])
if len(feats_info) == 2:
new_feats_info = (new_feats_info, feats_info[1])
else:
new_feats_info = (new_feats_info, feats_info[1], feats_info[2])
feats_info = _featuresmanager_parsing_creation(new_feats_info)
assert isinstance(feats_info, FeaturesManager)
return feats_info
def create_aggfeatures(sp_descriptor, features):
"""Average distance of points of the different regions.
Function to compute the spatial distances between regions.
Parameters
----------
sp_descriptor: tuple (aggregation_info format) or SpatialDescriptorModel
the information to compute aggregation.
features: pst.BaseFeatures
the features we want to aggregate.
Returns
-------
new_exlicit_features: pst.Features object
the features object obtained by aggregating the features.
"""
## 1. Computing
if type(sp_descriptor) == tuple:
## 0. Parsing inputs
disc_info, retriever_in, _, agg_info = sp_descriptor
assert type(agg_info) == tuple
assert len(agg_info) == 2
_, aggregating_feat = agg_info
agg_f_ret, desc_in, pars_feat_in, pars_feats, desc_out = _parse_aggregation_feat(aggregating_feat, features)
## Retrievers
locs, regs, disc = _discretization_parsing_creation(disc_info)
retrievers = agg_f_ret(retriever_in, locs, regs, disc)
## Featurers
# Feature creation
object_feats, core_features, pars_fea_o_in = features.export_features()
pars_fea_o_in["descriptormodel"] = desc_in
new_features = object_feats(core_features, **pars_fea_o_in)
# Feature manager creation
pars_feat_in["maps_vals_i"] = regs
pars_feat_in["selectors"] = (0, 0), (0, 0), (0, 0)
featurers = FeaturesManager(new_features, **pars_feat_in)
## 1. Preparing spdesc object
spdesc = SpatialDescriptorModel(retrievers, featurers)
## 2. Compute
aggfeatures = spdesc.compute()
else:
aggfeatures = sp_descriptor.compute()
pars_feats = {}
desc_out = sp_descriptor.featurers.features[0].descriptormodel
## 3. Creation of the object features aggregations
new_exlicit_features = _featuresobject_parsing_creation((aggfeatures, pars_feats, desc_out))
return new_exlicit_features
