def _readOut(self, readout_one_line, end_readOut): while self.step_in_readOut_range < self.len_readOut_range: i = self.readOut_range[self.step_in_readOut_range] #for i in readOut_range: line = linecache.getline(self.dat_file, i+1) file_dim = line[:-2].split(self.dim_seperator) self._assignValues(file_dim) if self.n == self.showBar_counter: self.bar_step += self.bar_step_delta _utils.statusBar(self.bar_step,self.sum_bar, 20) self.n = 0 self.n+= 1 self.step_in_readOut_range += 1 if readout_one_line: return False if end_readOut: return True return True # means i'm done with readout
def _printStatus(self): if not self.silent_readout: if self.n == self.showBar_counter: _utils.statusBar(self.n_line+1,self.len_dat_file) self.n = 0 self.n+= 1
def interpolateFine(self, **kwargs):
'''
interpolate NaNs (empty points) in matrix.
In contrast to :py:func:`interpolateFast` this function is comparatively slow.
Therefore it can take a some minutes to finish interpolation on mergeMatrices that have reslutions > 30 in each basisDimension.
However this function enables you to:
* blurring between points (*focusExponent*). Thus it is possible to get smooth intersections between heavy scattered values.
* extrapolate
* limit the maximum interpolation/extrapolation distance (related to the unit of the chosen basisDimension)
* weight distances in each basisDimension
**Optional kwargs** ("keyword arguments") are:
================== =============== ========= ================
Keyword Type Default Description
================== =============== ========= ================
*mergeName* list(mergeDim) [{all}] one or more merge-dims to do the method on
*focusExponent* float 10 blurring between points (sharpness will increase with increasing focusExponent)
*evalPointDensity* bool True weights the moments: 'moment = pointDensity*moment'
*maxDistance* dict {None} {basisName:maxDistance,..}
*distanceFactor* dict {1} {basisName:factor,..}
================== =============== ========= ================
.. math::
moment = 1/distance^{focusExponent}
'''
#standard
mergeNames = deepcopy(self.mergeNames)
focus_exponent = 5
eval_pointDesity = True
max_interpolate_distance_dict = {}
basis_distance_factor_dict = {}
basis_distance_factor = []
max_interpolate_distance =[]
for b in self._basis_dim:
max_interpolate_distance_dict[b.name] = None
basis_distance_factor_dict[b.name] = 1
max_interpolate_distance.append(None)
basis_distance_factor.append(1)
#individual
for key in kwargs:
if key == "mergeName":
mergeNames = []
if type(kwargs[key]) != list and type(kwargs[key]) != tuple:
kwargs[key] = [ kwargs[key] ]
for m in kwargs[key]:
if m not in self.mergeNames:
raise KeyError("ERROR: mergeName '%s' not known" %m)
mergeNames.append(m)
elif key == "method":
if kwargs[key] not in ["nearest", "linear", "cubic"]:
raise KeyError("ERROR: method '%s' not known" %kwargs[key])
else:
method = kwargs[key]
elif key == "focusExponent":
focus_exponent = float(abs(kwargs[key]))
elif key == "evalPointDensity":
eval_pointDesity = bool(kwargs[key])
elif key == "maxDistance":
for i in dict(kwargs[key]):
if i not in max_interpolate_distance_dict.keys():
raise KeyError("basisName '%s' in maxDistance not known" %i)
max_interpolate_distance_dict[i] = kwargs[key][i]
elif key == "distanceFactor":
for i in dict(kwargs[key]):
if i not in basis_distance_factor_dict.keys():
raise KeyError("basisName '%s' in distanceFactor not known" %i)
basis_distance_factor_dict[i] = kwargs[key][i]
else:
raise KeyError("keyword '%s' not known" %key)
max_moment = 1 / ( 0.5 **focus_exponent )
momentMatrix = deepcopy(self.mergeMatrix[0])
#generate list from dict sorted via indices
for i in basis_distance_factor_dict:
for n,b in enumerate(self._basis_dim):
if b.name == i:
basis_distance_factor[n] = basis_distance_factor_dict[i]
for i in max_interpolate_distance_dict:
for n,b in enumerate(self._basis_dim):
if b.name == i:
max_interpolate_distance[n] = max_interpolate_distance_dict[i]
#normalize distances
sumB = float(sum(basis_distance_factor))
for n in range(len(basis_distance_factor)):
basis_distance_factor[n] /= sumB
#prepare regarded-array-slice
n_regarded_cells = []
regarded_cell_range = []
abs_max_interpolation_dist = 0
pos_corr = []
for n,b in enumerate(self._basis_dim):
basis_distance_factor.append(1)
if max_interpolate_distance[n] != None:
cell_len = (b._include_range[1]-b._include_range[0]) / b.resolution
nCells = int(max_interpolate_distance[n] /cell_len)
if nCells == 0:
nCells = 1
n_regarded_cells.append(nCells)
abs_max_interpolation_dist += nCells
else:
n_regarded_cells.append(1)#dummy
regarded_cell_range.append(0)
pos_corr.append(0)
abs_max_interpolation_dist **= 0.5
print abs_max_interpolation_dist
try:
for m in mergeNames:
merge_index = self.mergeNames.index(m)
print "--> interpolate matrix %s" %m
mergeM = self.mergeMatrix[merge_index]
new_mergeM = deepcopy(mergeM)
densityM = self.densityMatrix[merge_index]
status_counter = 0
next_status = int(mergeM.size/100)
#len_matrix = len(mergeM)
for nPoi, poi in enumerate(np.ndindex( mergeM.shape ) ):
for n,b in enumerate(self._basis_dim):
# only work with a part of the matrix depending on the size
# of the regarded cell range
if max_interpolate_distance[n] != None:
start = poi[n] - n_regarded_cells[n]
if start < 0:
start= 0
stop = poi[n] + n_regarded_cells[n]
if stop > b.resolution-1:
stop= b.resolution-1
regarded_cell_range[n] = slice(start, stop)
pos_corr[n] = start
else:
regarded_cell_range[n] = slice(None,None)
t_regarded_cell_range = tuple(regarded_cell_range)
sliced_moment_matrix = momentMatrix[t_regarded_cell_range]
for mergePosition,mergeValue in np.ndenumerate(
mergeM[t_regarded_cell_range]):
#empty merge-positions have no moment
if np.isnan(mergeValue):
sliced_moment_matrix[mergePosition] = 0
else:
#calc distance of each mergePoint to each mergePoint
distance = 0
for k in range(self.nBasis):
distance += (abs(poi[k] -
(mergePosition[k] + pos_corr[k]) )*
basis_distance_factor[k]) **2
distance = distance**0.5
if distance == 0:
#above point of interest
sliced_moment_matrix[mergePosition] = max_moment
elif (max_interpolate_distance[n] != None and
distance > abs_max_interpolation_dist):
#no moments if to far away from existant points
sliced_moment_matrix[mergePosition] = np.nan
else:
#calc moments
sliced_moment_matrix[mergePosition] = 1 / (
distance **focus_exponent )
if eval_pointDesity:
#multiply moment with number of points
sliced_moment_matrix *= densityM[t_regarded_cell_range]
##normalize moments that sum(moments)=1
nansum = bn.nansum(sliced_moment_matrix)
if nansum != 0:
sliced_moment_matrix /= nansum
##mergeMatrix[point]=sum(moments*matrix)
new_mergeM[poi] = bn.nansum(
mergeM[t_regarded_cell_range] * sliced_moment_matrix )
status_counter += 1
if status_counter == next_status:
#print status
_utils.statusBar(nPoi+1, mergeM.size)
status_counter = 0
self.mergeMatrix[merge_index] = new_mergeM
except KeyboardInterrupt:
print "...interrupted"
print "done"
