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"