def IgorLoad(self,Source): from igor import binarywave,igorpy Waves={} Variables={} if Source[-3:] == 'ibw': Waves[binarywave.load(Source)['wave']['wave_header']['bname']]=binarywave.load(Source)['wave']['wData'] Variables['SampleInterval']=1 elif Source[-3:] == 'pxp': #tree=igorpy.load(Source).format() #print tree #print '#############' b=igorpy.load(Source) for i in b: if isinstance(i, igorpy.Wave): Waves[str(i.name)]=i.data elif isinstance(i, igorpy.Variables): Variables=i.uservar elif Source[-3:] == 'txt': b=numpy.loadtxt(Source) Waves[Source.split("/")[-1].replace('.txt','').replace('.','_')]=b Variables=None elif Source[-3:] == 'csv': b=numpy.loadtxt(Source) Waves[Source.split("/")[-1].replace('.txt','').replace('.','_')]=b Variables=None elif Source[-3:] == 'wcp': print "not supported yet, but you can import an igor file" b,c=self.read_block(Source) for i,j in enumerate(b): Waves[str(j[0])+str(i)]=numpy.array(j[1]) for i in c: Variables[i]=c[i] try: return Waves,Variables except UnboundLocalError: msgBox = QtGui.QMessageBox() msgBox.setText( """ <b>Filtype not Supported</b> <p>Only txt, ibw and pxp files are supported """) msgBox.exec_() return None, None
def main(input_filename, output_filename): track = audio.LocalAudioFile(input_filename) sections, segments = track.analysis.sections, track.analysis.segments fsegs, i = [], 0 for section in sections: while segments[i].start <= section.start: i = i + 1 fsegs.append(segments[i - 1]) ssmp, ssmt, p1, p2, t1, t2 = [], [], [], [], [], [] for s1 in fsegs: p1, t1 = s1.pitches, s1.timbre for s2 in fsegs: p2, t2 = s2.pitches, s2.timbre distp, distt = 0, 0 for j in range(len(p1)): distp = distp + (p2[j] - p1[j])**2 for k in range(len(t1)): distt = distt + (t2[k] - t1[k])**2 ssmp.append(distp**0.5) ssmt.append(distt**0.5) ssmp = numpy.array(ssmp).reshape(len(fsegs), len(fsegs)) ssmt = numpy.array(ssmt).reshape(len(fsegs), len(fsegs)) plt.imshow(ssmp, 'gray') plt.title('Section SSM (Pitches)') plt.colorbar() plt.savefig(output_filename + '_pitch') plt.show() plt.imshow(ssmt, 'gray') plt.title('Section SSM (Timbre)') plt.colorbar() plt.savefig(output_filename + '_timbre') plt.show()
def plotData(fileName): xVals, yVals = getData(fileName) xVals = numpy.array(xVals) yVals = numpy.array(yVals) xVals = xVals * 9.81 #acc. due to gravity numpy.plot(xVals, yVals, 'bo', label='Measured displacements') labelPlot()
def get_test_dataset(): x_return_test = np.zeros((117, size, size, size)) x_name_test = pd.read_csv("test.csv")['Id'] filenum = 0 for i in range(117): x_file_temp = os.path.join(x_test_path, x_name_test[i] + '.npz') x_voxel = np.array(np.load(x_file_temp)['voxel']) x_seg = np.array(np.load(x_file_temp)['seg']) x_temp = x_voxel * x_seg * 0.8 + x_voxel * 0.2 s = x_seg * x_voxel sign = np.array(np.nonzero(s)) min1, low1, len1 = get_rec(sign, 0) min2, low2, len2 = get_rec(sign, 1) min3, low3, len3 = get_rec(sign, 2) i_temp = 0 for i in range(low1, low1+len1): j_temp = 0 for j in range(low2, low2+len2): k_temp = 0 for k in range(low3, low3+len3): x_return_test[filenum, i, j, k] = x_temp[min1 + i_temp, min2 + j_temp, min3 + k_temp] k_temp += 1 j_temp += 1 i_temp += 1 filenum += 1 return x_return_test
def plotLIE(trainSet): x=np.array([ i['Gexp'] for i in trainSet ]) y=np.array([ i['Gcalc'] for i in trainSet ]) minAxi=min([x.min(), y.min()]) maxAxi=max([x.max(), y.max()]) minAxi= 5*((minAxi//5)) maxAxi= 5*((maxAxi//5)+1) fig = plt.figure() ax = fig.add_subplot(111, aspect='equal') plt.setp(ax.get_xticklabels(), rotation='horizontal', fontsize=20) plt.setp(ax.get_yticklabels(), rotation='horizontal', fontsize=20) plt.xlabel('$\Delta$G$_{obs}$', fontsize=20, color='black') plt.ylabel(r'$\Delta$G$_{calc}$', fontsize=20, color='black') plt.axis([minAxi,maxAxi, minAxi, maxAxi]) plt.plot(x,y, 'ro') plt.plot([minAxi,maxAxi],[minAxi,maxAxi],color='black', linestyle='-') plt.plot([minAxi,maxAxi-5],[minAxi+5,maxAxi],color='black', linestyle='-.') plt.plot([minAxi+5,maxAxi],[minAxi,maxAxi-5],color='black', linestyle='-.') for i,(x,y) in enumerate(zip(x,y)): ax.annotate(i+1,xy=(x,y),xytext=(5,0),textcoords='offset points') plt.tight_layout() imgdata = BytesIO() fig.savefig(imgdata, format='svg') imgdata.seek(0) # rewind the data return imgdata
def load_traindata(): x_return = np.zeros((495, size, size, size)) x_name = pd.read_csv("train_val.csv")[ 'Id'] # 此处[' ']内填写的是train_val.csv内的第一列表头 count_file = 0 for i in range(len(traindata_list)): x_file_temp = os.path.join(traindata_path, x_name[i] + '.npz') x_voxel = np.array(np.load(x_file_temp)['voxel']) x_mask = np.array(np.load(x_file_temp)['seg']) x_temp = x_voxel * x_mask * 0.8 + x_voxel * 0.2 list_xx = x_mask * x_voxel list_xx_nz = np.array(np.nonzero(list_xx)) coor1min = list_xx_nz[0, :].min() coor1max = list_xx_nz[0, :].max() coor1len = coor1max - coor1min + 1 coor1bigger = coor1len - size if coor1bigger > 0: coor1min += coor1bigger // 2 coor1max -= coor1bigger - coor1bigger // 2 coor1len = size coor1low = (size // 2) - (coor1len // 2) coor1high = coor1low + coor1len coor2min = list_xx_nz[1, :].min() coor2max = list_xx_nz[1, :].max() coor2len = coor2max - coor2min + 1 coor2bigger = coor2len - size if coor2bigger > 0: coor2min += coor2bigger // 2 coor2max -= coor2bigger - coor2bigger // 2 coor2len = size coor2low = (size // 2) - (coor2len // 2) coor2high = coor2low + coor2len coor3min = list_xx_nz[2, :].min() coor3max = list_xx_nz[2, :].max() coor3len = coor3max - coor3min + 1 coor3bigger = coor3len - size if coor3bigger > 0: coor1min += coor3bigger // 2 coor3max -= coor3bigger - coor3bigger // 2 coor3len = size coor3low = (size // 2) - (coor3len // 2) coor3high = coor3low + coor3len coorlist1 = 0 for coor1 in range(coor1low, coor1high): coorlist2 = 0 for coor2 in range(coor2low, coor2high): coorlist3 = 0 for coor3 in range(coor3low, coor3high): x_return[count_file, coor1, coor2, coor3] = x_temp[coor1min + coorlist1, coor2min + coorlist2, coor3min + coorlist3] coorlist3 += 1 coorlist2 += 1 coorlist1 += 1 count_file += 1 return x_return
def load_testdata(): x_return = np.zeros((117, size, size, size)) x_name = pd.read_csv("sampleSubmission.csv")[ 'Id'] # 此处[' ']内填写的是sampleSubmission.csv内的第一列表头 filenum = 0 for i in range(117): x_file_temp = os.path.join(x_test_path, x_name[i] + '.npz') x_voxel = np.array(np.load(x_file_temp)['voxel']) x_mask = np.array(np.load(x_file_temp)['seg']) x_temp = x_voxel * x_mask * 0.8 + x_voxel * 0.2 list_xx_test = x_voxel * x_mask list_xx_nz_test = np.array(np.nonzero(list_xx_test)) coor1min = list_xx_nz_test[0, :].min() coor1max = list_xx_nz_test[0, :].max() coor1len = coor1max - coor1min + 1 coor1bigger = coor1len - size if coor1bigger > 0: coor1min += coor1bigger // 2 coor1max -= coor1bigger - coor1bigger // 2 coor1len = size coor1low = (size // 2) - (coor1len // 2) coor1high = coor1low + coor1len coor2min = list_xx_nz_test[1, :].min() coor2max = list_xx_nz_test[1, :].max() coor2len = coor2max - coor2min + 1 coor2bigger = coor2len - size if coor2bigger > 0: coor2min += coor2bigger // 2 coor2max -= coor2bigger - coor2bigger // 2 coor2len = size coor2low = (size // 2) - (coor2len // 2) coor2high = coor2low + coor2len coor3min = list_xx_nz_test[2, :].min() coor3max = list_xx_nz_test[2, :].max() coor3len = coor3max - coor3min + 1 coor3bigger = coor3len - size if coor3bigger > 0: coor1min += coor3bigger // 2 coor3max -= coor3bigger - coor3bigger // 2 coor3len = size coor3low = (size // 2) - (coor3len // 2) coor3high = coor3low + coor3len # print(file, coor1low, coor1high, coor2low, coor2high, coor3low, coor3high) coorlist1 = 0 for coor1 in range(coor1low, coor1high): coorlist2 = 0 for coor2 in range(coor2low, coor2high): coorlist3 = 0 for coor3 in range(coor3low, coor3high): x_return[filenum, coor1, coor2, coor3] = x_temp[coor1min + coorlist1, coor2min + coorlist2, coor3min + coorlist3] coorlist3 += 1 coorlist2 += 1 coorlist1 += 1 filenum += 1 return x_return
def fitData1(fileName): xVals, yVals = getData(fileName) xVals = numpy.array(xVals) yVals = numpy.array(yVals) xVals = xVals * 9.81 #get force numpy.plot(xVals, yVals, 'bo', label='Measured points') labelPlot() model = numpy.polyfit(xVals, yVals, 1) estYVals = numpy.polyval(model, xVals) numpy.plot(xVals, estYVals, 'r', label='Linear fit, k = ' + str(round(1 / model[0], 5))) numpy.legend(loc='best')
def fitData(fileName): xVals, yVals = getData(fileName) xVals = numpy.array(xVals) yVals = numpy.array(yVals) xVals = xVals * 9.81 #get force numpy.plot(xVals, yVals, 'bo', label='Measured points') labelPlot() a, b = numpy.polyfit(xVals, yVals, 1) estYVals = a * numpy.array(xVals) + b print('a =', a, 'b =', b) numpy.plot(xVals, estYVals, 'r', label='Linear fit, k = ' + str(round(1 / a, 5))) numpy.legend(loc='best')
def many(self, inputimages, clobber=True, depth=-1, limit=25, single=True, **options): '''Display a bunch of images in ds9, each in its own frame.''' images = np.array(inputimages) if clobber: self.window.set("frame delete all") if single: self.window.set('single') else: self.window.set('tile') # is the "cube" really just a 1D or 2D image? if len(images.shape) <= 2: self.one(images, clobber=clobber) return # loop through the "depth" axis, which is by default the final one if len(images.shape) == 3: # only display up to a certain number of images if images.shape[-1] > limit: self.speak("going to display only {0:.0f} images, for impatience's sake".format(limit)) # display all the images for i in range(np.minimum(images.shape[depth], limit)): self.replace(images.take(i,axis=depth).astype(np.float), i) self.applyOptionsToFrame(**options) return self.speak('Uh-oh! Image array seems to have a dimension other than 1, 2, or 3!')
def geometricMeanFilter(self, img): img = img.convert('RGB') px = img.load() width, height = img.size result = np.array(img) kernel_dim = 1 #(*2+1) # kernel 3x3 for i in range(kernel_dim, height - kernel_dim): for j in range(kernel_dim, width - kernel_dim): prod_red, prod_green, prod_blue = (1, 1, 1) for n in range(i - kernel_dim, i + kernel_dim + 1): for m in range(j - kernel_dim, j + kernel_dim + 1): r, g, b = px[m, n] prod_red *= r prod_green *= g prod_blue *= b div = (kernel_dim * 2 + 1)**2 result[i, j] = tuple([ prod_red**(1 / div), prod_green**(1 / div), prod_blue**(1 / div) ]) img = Image.fromarray(result) return img
def harmonicMeanFilter(self, img): img = img.convert('RGB') px = img.load() width, height = img.size result = np.array(img) kernel_dim = 1 # (*2+1) # kernel 3x3 for i in range(kernel_dim, height - kernel_dim): for j in range(kernel_dim, width - kernel_dim): sum_red, sum_green, sum_blue = (0, 0, 0) for n in range(i - kernel_dim, i + kernel_dim + 1): for m in range(j - kernel_dim, j + kernel_dim + 1): r, g, b = px[m, n] if r == 0: r = 1 if g == 0: g = 1 if b == 0: b = 1 sum_red += 1 / r sum_green += 1 / g sum_blue += 1 / b num = (kernel_dim * 2 + 1)**2 result[i, j] = tuple([ int(num / sum_red), int(num / sum_green), int(num / sum_blue) ]) img = Image.fromarray(result) return img
def contrastFilter(self, index, img): img = img.convert('RGB') open_cv_image = np.array(img) # Select the three different channels red = open_cv_image[:, :, 0] green = open_cv_image[:, :, 1] blue = open_cv_image[:, :, 2] # factor used to apply the contrast function factor = (259.0 * (index + 255.0)) / (255.0 * (259.0 - index)) # Calculate the new value for each pixel in the channel red = factor * (red - 128.0) + 128.0 green = factor * (green - 128.0) + 128.0 blue = factor * (blue - 128.0) + 128.0 # Ensure that the value of pixels not go out of RGB range red[red >= 255] = 255 red[red <= 0] = 0 green[green >= 255] = 255 green[green <= 0] = 0 blue[blue >= 255] = 255 blue[blue <= 0] = 0 # Set the matrix image with the new arrays open_cv_image[:, :, 0] = red open_cv_image[:, :, 1] = green open_cv_image[:, :, 2] = blue # Convert the matrix to a PIL image that will show in the label img = Image.fromarray(open_cv_image) return img
def arithmeticMeanFilter(self, img): img = img.convert('RGB') im = np.array(img) red = im[:, :, 0] green = im[:, :, 1] blue = im[:, :, 2] w = 2 for i in range(w, im.shape[0] - w): for j in range(w, im.shape[1] - w): block_red = red[i - w:i + w + 1, j - w:j + w + 1] m_r = np.mean(block_red, dtype=np.float32) red[i][j] = int(m_r) block_green = green[i - w:i + w + 1, j - w:j + w + 1] m_g = np.mean(block_green, dtype=np.float32) green[i][j] = int(m_g) block_blue = blue[i - w:i + w + 1, j - w:j + w + 1] m_r = np.mean(block_blue, dtype=np.float32) blue[i][j] = int(m_r) im[:, :, 0] = red im[:, :, 1] = green im[:, :, 2] = blue img = Image.fromarray(im) img = img.convert('RGB') return img
def medianFilter(self, img): img = img.convert('RGB') im = np.array(img) ''' SLOW OLD IMPLEMENTATION red = im[:, :, 0] green = im[:, :, 1] blue = im[:, :, 2] w = 1 for i in range(w, im.shape[0] - w): for j in range(w, im.shape[1] - w): block_red = red[i - w:i + w + 1, j - w:j + w + 1] m_r = np.median(block_red) red[i][j] = int(m_r) block_green = green[i - w:i + w + 1, j - w:j + w + 1] m_g = np.median(block_green) green[i][j] = int(m_g) block_blue = blue[i - w:i + w + 1, j - w:j + w + 1] m_r = np.median(block_blue) blue[i][j] = int(m_r) im[:, :, 0] = red im[:, :, 1] = green im[:, :, 2] = blue ''' im = cv2.medianBlur(im, 11) img = Image.fromarray(im) img = img.convert('RGB') return img
def drogEdgeDetectorFilter(self, img, ret_grad=False, pillow=True): if pillow: img = img.convert('L') open_cv_image = np.array(img) width, height = 0, 0 if not pillow: height, width = img.shape else: width, height = img.size cv2.GaussianBlur(open_cv_image, (15, 15), 0) # Create sobel x and y matrix sobel_x = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]) sobel_y = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]]) kernel1 = np.zeros(open_cv_image.shape) kernel1[:sobel_x.shape[0], :sobel_x.shape[1]] = sobel_x kernel1 = np.fft.fft2(kernel1) kernel2 = np.zeros(open_cv_image.shape) kernel2[:sobel_y.shape[0], :sobel_y.shape[1]] = sobel_y kernel2 = np.fft.fft2(kernel2) im = np.array(open_cv_image) fim = np.fft.fft2(im) Gx = np.real(np.fft.ifft2(kernel1 * fim)).astype(float) Gy = np.real(np.fft.ifft2(kernel2 * fim)).astype(float) open_cv_image = abs(Gx/4) + abs(Gy/4) img = Image.fromarray(open_cv_image) img = img.convert('L') if ret_grad: return Gx, Gy return img
def scaling(self, img, index, resize=False): img = img.convert('RGB') im = np.array(img) red = im[:, :, 0] green = im[:, :, 1] blue = im[:, :, 2] width, height = img.size # Calculate the second index value to maintain the aspect ratio aspect_ratio = width / height index1 = index index2 = int((index1 + width - (aspect_ratio * height)) / aspect_ratio) new_img = img.resize((width - index1, height - index2)) new_img = np.array(new_img) new_red = np.zeros((height - index2, width - index1)) new_green = np.zeros((height - index2, width - index1)) new_blue = np.zeros((height - index2, width - index1)) if index > 0: new_red[:, :] = red[0:height - index2, 0:width - index1] new_green[:, :] = green[0:height - index2, 0:width - index1] new_blue[:, :] = blue[0:height - index2, 0:width - index1] else: new_red[0:height, 0:width] = red[:, :] new_green[0:height, 0:width] = green[:, :] new_blue[0:height, 0:width] = blue[:, :] new_img[:, :, 0] = new_red new_img[:, :, 1] = new_green new_img[:, :, 2] = new_blue if not resize: img = Image.fromarray(new_img) img = img.resize((width, height)) else: img = img.resize((width + index1, height + index2)) return img
def statisticalRegionMerging(self, img, n_sample): img = img.convert('RGB') image = np.array(img) srm = SRM(image, n_sample) segmented = srm.run() segmented = np.array(segmented).astype(int) red = segmented[:, :, 0] green = segmented[:, :, 1] blue = segmented[:, :, 2] image[:, :, 0] = red image[:, :, 1] = green image[:, :, 2] = blue img = Image.fromarray(image) return img
def getDiffs(population, sampleSizes): popStd = numpy.std(population) diffsFracs = [] for sampleSize in sampleSizes: diffs = [] for t in range(100): sample = random.sample(population, sampleSize) diffs.append(abs(popStd - numpy.std(sample))) diffMean = sum(diffs)/len(diffs) diffsFracs.append(diffMean/popStd) return numpy.array(diffsFracs)*100
def fitData(fileName): xVals, yVals = getData(fileName) xVals = numpy.array(xVals) yVals = numpy.array(yVals) xVals = xVals*9.81 #get force numpy.plot(xVals, yVals, 'bo', label = 'Measured points') model = numpy.polyfit(xVals, yVals, 1) xVals = xVals + [2] yVals = yVals + [] estYVals = numpy.polyval(model, xVals) numpy.plot(xVals, estYVals, 'r', label = 'Linear fit, r**2 = ' + str(round(rSquared(yVals, estYVals), 5))) model = numpy.polyfit(xVals, yVals, 2) estYVals = numpy.polyval(model, xVals) numpy.plot(xVals, estYVals, 'g--', label = 'Quadratic fit, r**2 = ' + str(round(rSquared(yVals, estYVals), 5))) numpy.title('A Linear Spring') labelPlot() numpy.legend(loc = 'best')
def fftdc(compressed): file_for_decompression = compressed col_idft = np.transpose(file_for_decompression) col_idft = [np.fft.ifft(row) for row in col_idft] row_idft = np.transpose(col_idft) row_idft = [np.fft.ifft(row) for row in row_idft] # file_for_decompression = np.array([shuffle(row) for row in row_idft]) # file_for_decompression = np.transpose(file_for_decompression) # file_for_decompression = np.array([shuffle(row) for row in file_for_decompression]) # file_for_decompression = np.transpose(file_for_decompression) return np.array(row_idft)
def plot_RMSD_histo(plotFilePath, plotFilePath2, dots, plotTitle): rmsd = np.array(dots)[:, 1] xlabel = None ylabel = None meanX, stdX = HGM.helpers.compute_list_statistics(rmsd) minX = min(rmsd) maxX = max(rmsd) title = plotTitle+\ "range:[{3:.2f},{4:.2f}]\n size:{0:d} E{1:.2f}: s{2:.2f}:".format(len(rmsd),meanX,stdX,minX,maxX) HGM.helpersPlot.plot_histogram_with_margins(plotFilePath2, rmsd, nbBins, xlabel, ylabel, title) HGM.helpersPlot.plot_histogram(plotFilePath, rmsd, nbBins, xlabel, ylabel, title)
def shuffle(row): N = math.ceil(math.log2(len(row))) new_row = np.array([0] * 2**N) for i in range(len(row)): formated = format(i, '0' + str(N) + 'b') reversed_string = [ formated[len(formated) - 1 - k] for k in range(len(formated)) ] formated = '' for j in reversed_string: formated += j formated = int(formated, 2) new_row[formated] = int(row[i]) return new_row
def saturationFilter(self, index, img): img = img.convert('RGB') open_cv_image = np.array(img) # Same logic of luminance filter hsv = cv2.cvtColor(open_cv_image, cv2.COLOR_RGB2HSV).astype("float32") s = hsv[:, :, 1] s += index s[s >= 255] = 255 s[s <= 0] = 0 hsv[:, :, 1] = s img = cv2.cvtColor(hsv.astype("uint8"), cv2.COLOR_HSV2RGB) img = Image.fromarray(img) return img
def graph_plotting(dict_of_data, A, B, X_title, Y_title): x = dict_of_data.get('x') dx = dict_of_data.get('dx') y = dict_of_data.get('y') dy = dict_of_data.get('dy') x_array = num.array(x) lin_fun = A * x_array + B #graph plotting with errorbars pyplot.plot(x_array, lin_fun, 'r') pyplot.errorbar(x, y, dx, dy, fmt=none, ecolor='b') pyplot.xlabel(x_title) pyplot.ylabel(y_title) pyplot.show() pyplot.savefig('linear_fit.svg')
def luminanceFilter(self, index, img): img = img.convert('RGB') open_cv_image = np.array(img) # Change color space to use the Value of HSV to manipulate the luminance # the rest of code is similar to other color filter hsv = cv2.cvtColor(open_cv_image, cv2.COLOR_RGB2HSV).astype("float32") v = hsv[:, :, 2] v += index v[v >= 255] = 255 v[v <= 0] = 0 hsv[:, :, 2] = v img = cv2.cvtColor(hsv.astype("uint8"), cv2.COLOR_HSV2RGB) img = Image.fromarray(img) return img
def translate(self, img, x, y): img = img.convert('RGB') open_cv_image = np.array(img) red = open_cv_image[:, :, 0] green = open_cv_image[:, :, 1] blue = open_cv_image[:, :, 2] x = -x red = np.roll(red, x, axis=0) if x >= 0: red[:x, :] = 0 else: red[img.height + x:, :] = 0 red = np.roll(red, y, axis=1) if y >= 0: red[:, :y] = 0 else: red[:, img.width + y:] = 0 green = np.roll(green, x, axis=0) if x >= 0: green[:x, :] = 0 else: green[img.height + x:, :] = 0 green = np.roll(green, y, axis=1) if y >= 0: green[:, :y] = 0 else: green[:, img.width + y:] = 0 blue = np.roll(blue, x, axis=0) if x >= 0: blue[:x, :] = 0 else: blue[img.height + x:, :] = 0 blue = np.roll(blue, y, axis=1) if y >= 0: blue[:, :y] = 0 else: blue[:, img.width + y:] = 0 open_cv_image[:, :, 0] = red open_cv_image[:, :, 1] = green open_cv_image[:, :, 2] = blue open_cv_image = abs(open_cv_image) img = Image.fromarray(open_cv_image) return img
def arithmeticMeanFilter(self, img): img = img.convert('RGB') im = np.array(img) ''' SLOW OLD IMPLEMENTATION red = im[:, :, 0] green = im[:, :, 1] blue = im[:, :, 2] w = 2 for i in range(w, im.shape[0] - w): for j in range(w, im.shape[1] - w): block_red = red[i - w:i + w + 1, j - w:j + w + 1] m_r = np.mean(block_red, dtype=np.float32) red[i][j] = int(m_r) block_green = green[i - w:i + w + 1, j - w:j + w + 1] m_g = np.mean(block_green, dtype=np.float32) green[i][j] = int(m_g) block_blue = blue[i - w:i + w + 1, j - w:j + w + 1] m_r = np.mean(block_blue, dtype=np.float32) blue[i][j] = int(m_r) im[:, :, 0] = red im[:, :, 1] = green im[:, :, 2] = blue ''' kernel = np.ones((11, 11), np.float32) / 121 im = cv2.filter2D(im, -1, kernel) img = Image.fromarray(im) img = img.convert('RGB') return img
def showErrorBars(population, sizes, numTrials): xVals = [] sizeMeans, sizeSDs = [], [] for sampleSize in sizes: xVals.append(sampleSize) trialMeans = [] for t in range(numTrials): sample = random.sample(population, sampleSize) popMean, sampleMean, popSD, sampleSD =\ getMeansAndSDs(population, sample) trialMeans.append(sampleMean) sizeMeans.append(sum(trialMeans)/len(trialMeans)) sizeSDs.append(numpy.std(trialMeans)) print(sizeSDs) numpy.errorbar(xVals, sizeMeans, yerr = 1.96*numpy.array(sizeSDs), fmt = 'o', label = '95% Confidence Interval') numpy.title('Mean Temperature (' + str(numTrials) + ' trials)') numpy.xlabel('Sample Size') numpy.ylabel('Mean') numpy.axhline(y = popMean, color ='r', label = 'Population Mean') numpy.xlim(0, sizes[-1] + 10) numpy.legend()
def Update_Navigate(self): #Resetting Sequence try: RecordA0=Navigate.ArrayList[0] except IndexError: msgBox = QtGui.QMessageBox() msgBox.setText( """ <b>No Data</b> <p>No data match your filter paramterers Caution, Filtering is case-sensitive """) msgBox.exec_() return Requete.url=None Requete.Current_Signal=RecordA0 #if Navigate.VarList.has_key("sampling_rate") == True: # Navigate.VarList["sampling_rate"]=Navigate.VarList["sampling_rate"]*1000. # Navigate.VarList["SampleInterval"]=Navigate.VarList["sampling_rate"] try: if self.FileType == "Neuromatic":#Navigate.VarList.has_key("SampleInterval") == True: Requete.timescale=(Navigate.VarList["SampleInterval"])*numpy.array(range(len(RecordA0[0]))) Requete.Analogsignal_sampling_rate=list([1000./Navigate.VarList["SampleInterval"]]*len(Navigate.ArrayList)) elif self.FileType=="Synaptics":#Navigate.VarList.has_key("sampling_rate") == True: Requete.timescale=(1./Navigate.VarList["sampling_rate"])*numpy.array(range(len(RecordA0[0]))) Requete.Analogsignal_sampling_rate=list([1000.*Navigate.VarList["sampling_rate"]]*len(Navigate.ArrayList)) elif self.FileType=="WinWCP":#Navigate.VarList.has_key("sampling_rate") == True: Requete.timescale=(1000./Navigate.VarList["sampling_rate"])*numpy.array(range(len(RecordA0[0]))) Requete.Analogsignal_sampling_rate=list([Navigate.VarList["sampling_rate"]]*len(Navigate.ArrayList)) except KeyError: val, ok = QtGui.QInputDialog.getText(self,'Sampling rate not found', 'Please enter sampling interval (ms per point)') val=float(val) Navigate.VarList["SampleInterval"] = val Requete.timescale = val*numpy.array(range(len(RecordA0[0]))) Requete.Analogsignal_sampling_rate=list([len(Requete.Current_Signal[0])]*len(Navigate.ArrayList)) msgBox = QtGui.QMessageBox() msgBox.setText( """ <b>NeuroMatic Import Error</b> <p>Sampling rate not found, and set to %s """ %val) msgBox.exec_() #else: # TODO : Add manual SR input #print "filtype not identified, Auto sampling rate ignored" #Navigate.VarList["SampleInterval"] = 1. #Requete.timescale = 1.*numpy.array(range(len(RecordA0))) #Requete.Analogsignal_sampling_rate=list([len(Requete.Current_Signal)]*len(Navigate.ArrayList)) Requete.Shortest_Sweep_Length=(Requete.timescale[-1]+(Requete.timescale[1]-Requete.timescale[0]))/1000. #in s if Navigate.VarList.has_key("sampling_rate") == True: Navigate.Points_by_ms = Navigate.VarList["sampling_rate"] Requete.BypassedSamplingRate=Navigate.VarList["sampling_rate"] Navigate.VarList["SampleInterval"]=1000./Navigate.VarList["sampling_rate"] else: Navigate.Points_by_ms = 1000./ Navigate.VarList["SampleInterval"] Requete.BypassedSamplingRate=1000./Navigate.VarList["SampleInterval"] Navigate.VarList["sampling_rate"]=1000/Navigate.VarList["SampleInterval"] Requete.Current_Sweep_Number=0 Requete.Block_ids=list([[0]*Requete.NumberofChannels]*len(Navigate.ArrayList)) Requete.Block_date=list([[None]*Requete.NumberofChannels]*len(Navigate.ArrayList)) Requete.Segment_ids=[[x]*Requete.NumberofChannels for x in range(len(Navigate.ArrayList))] Requete.Analogsignal_ids=[[x]*Requete.NumberofChannels for x in range(len(Navigate.ArrayList))]#range(len(Navigate.ArrayList)) Requete.Analogsignal_name=list([None]*len(Navigate.ArrayList)) Requete.tag={} new=[] for i in range(len(Requete.Analogsignal_ids)): new.append([0]*int(Requete.NumberofChannels)) Requete.tag["Selection"]=new for i in range(len(Requete.Analogsignal_ids)): for j in range(Requete.NumberofChannels): Requete.tag["Selection"][i][j]=0 #Requete.tag["Selection"]=[[0]*int(Requete.NumberofChannels)]*len(Requete.Analogsignal_ids) Requete.Analogsignal_channel=list([range(Requete.NumberofChannels)]*len(Navigate.ArrayList)) Requete.Block_fileOrigin=list([None]*len(Navigate.ArrayList)) Requete.Block_Info=list([[None]*Requete.NumberofChannels]*len(Navigate.ArrayList)) if Navigate.VarList.has_key("SamplesPerWave") == True: Requete.Analogsignal_signal_shape=list([int(Navigate.VarList["SamplesPerWave"])]*len(Navigate.ArrayList)) else: Requete.Analogsignal_signal_shape=list([int(len(Requete.Current_Signal)*Requete.Shortest_Sweep_Length)]*len(Navigate.ArrayList)) Main.slider.setRange(0, len(Requete.Analogsignal_ids)-1) #definit le range du slider sweepnb Requete.Spiketrain_ids=list([None]*len(Navigate.ArrayList)) Requete.Spiketrain_neuron_name=list([None]*len(Navigate.ArrayList)) Requete.Spiketrain_t_start=list([None]*len(Navigate.ArrayList)) Requete.Spiketrain_Neuid=list([None]*len(Navigate.ArrayList)) for i in [Mapping.X_Start_Field, Mapping.X_End_Field, Mapping.X_Step_Field, Mapping.Y_Start_Field, Mapping.Y_End_Field, Mapping.Y_Step_Field]: i.setEnabled(True) Mapping.Scanning_Direction_Mode = None Main.To.setText(str(len(Requete.Analogsignal_ids)-1)) Navigate.Check_From_To() Main.MainFigure.canvas.fig.clf() Navigate.Display_First_Trace()
def Update_Graph(self,sender): sender=str(sender) if 'Button_Min' in sender: value=eval(sender).text() pos=int(sender[-1]) try: self.MinGuess[pos]=float(value) except ValueError: self.MinGuess[pos]=None pass if 'Button_Max' in sender: value=eval(sender).text() pos=int(sender[-1]) try: self.MaxGuess[pos]=float(value) except ValueError: self.MaxGuess[pos]=None pass elif 'Button_Guess' in sender: value=eval(sender).text() pos=int(sender[-1]) try: self.param_list[pos]=float(value) except ValueError: self.param_list[pos]=None pass elif 'Display_' in sender: value=eval(sender).text() pos=int(sender[-1]) try: self.display_range[pos]=float(value) except ValueError: self.display_range[pos]=1.0 pass elif 'Range' in sender: value=eval(sender).text() pos=int(sender[-1]) try: self.range[pos]=float(value) except ValueError: self.range[pos]=1.0 pass else: pass #fitting function is set function=eval('self.'+str(self.List_of_Functions.currentText()).lower()) #Graph is cleared self.Fit_Example.canvas.axes.clear() timescale=1. if str(self.Data_Wave.currentText()) != 'None': y=numpy.array(eval(str(self.Data_Wave.currentText()))) if str(self.Data_Wave_Axes.currentText()) == 'None': x=numpy.arange(len(y)) else: try: x=numpy.array(eval(str(self.Data_Wave_Axes.currentText()))) except SyntaxError: #should be corrected x=numpy.arange(len(y)) timescale=abs(x[1]-x[0]) A,=self.Fit_Example.canvas.axes.plot(x,y,'g') else: print 'No Data Wave defined (yet)' return Bounds=[] for i in range(10): Bounds.append([self.MinGuess[i],self.MaxGuess[i]]) fit=self.Fit(x,X=x,function=str(self.List_of_Functions.currentText()).lower(),Guess=self.param_list,StartX=self.range[0],EndX=self.range[1],Number_of_points=len(x),Rendering = False,Bounds=Bounds,Model=True) B,=self.Fit_Example.canvas.axes.plot(x,fit,'r') #The fitting guess self.Fit_Example.canvas.axes.legend([A,B], ["Data", "Model"], loc='best',fancybox=True) self.Fit_Example.canvas.axes.axvspan(self.range[0], self.range[1], -2000, 2000,color='r',alpha=0.1) if self.fixed_range.checkState()==2: self.Fit_Example.canvas.axes.set_xbound(self.display_range[0],self.display_range[1]) self.Fit_Example.canvas.axes.set_ybound(self.display_range[2],self.display_range[3]) else: self.Display_Range_0.setText(str(self.Fit_Example.canvas.axes.get_xbound()[0])) self.Display_Range_1.setText(str(self.Fit_Example.canvas.axes.get_xbound()[1])) self.Display_Range_2.setText(str(self.Fit_Example.canvas.axes.get_ybound()[0])) self.Display_Range_3.setText(str(self.Fit_Example.canvas.axes.get_ybound()[1])) self.display_range[0]=self.Fit_Example.canvas.axes.get_xbound()[0] self.display_range[1]=self.Fit_Example.canvas.axes.get_xbound()[1] self.display_range[2]=self.Fit_Example.canvas.axes.get_ybound()[0] self.display_range[3]=self.Fit_Example.canvas.axes.get_ybound()[1] self.Fit_Example.canvas.draw()
def find_indexes(Source,Min,Max): c=abs(numpy.array(Source)-Min) Min_index=list(c).index(min(c)) c=abs(numpy.array(Source)-Max) Max_index=list(c).index(min(c)) return Min_index,Max_index
def Fit(self,Source,X=None,function='line',Guess=numpy.ones(10),Show_Residuals=True,StartP=None,EndP=None,StartX=None,EndX=None,Show_Guess=False,Figure=None,Rendering=True,RAW_Data=True,Color='r',Show_Parameters=True,Number_of_points=1000.,Bounds=[[None,None]]*10,Model=False): """ Source is the signal to fit X is the XScale function is the fitting function. Avaible functions are : line, poly2, poly3, poly4, gauss, exp, double_exp, double_exp_xoffset, sin, hill, sigmoid, power, beta p0 are the intitial guesses (default is a list of 1.) StartP and EndP are the start point and the End point of the fit (in points) StartX and EndX are the start point and the End point of the fit (in timescale units) """ def find_indexes(Source,Min,Max): c=abs(numpy.array(Source)-Min) Min_index=list(c).index(min(c)) c=abs(numpy.array(Source)-Max) Max_index=list(c).index(min(c)) return Min_index,Max_index begin=X[0] #original begin and end points are stored here, so the final plot will be displayed in the original workspace end=X[-1] if (StartP == None) and (StartX == None) : StartP=0 StartX=0 if (EndP == None) and (EndX == None) == None: EndP=len(Source)-1 EndX=len(Source)-1 if (StartP == None) or (EndP == None) : StartP,EndP=find_indexes(X,StartX,EndX) else: StartX=X[StartP] EndX=X[EndP] Source=numpy.array(Source[StartP:EndP]) #if not using the whole range for the fit, truncated wave is created here X=numpy.array(X[StartP:EndP]) #if not using the whole range for the fit, truncated timescale is created here # Data and Xscale Source = numpy.array(Source) if X==None or (len(Source) != len(X)): X = numpy.array(range(len(Source))) # create a set of Parameters Function=eval("self."+function) #the fitting function Formula=eval("self."+function.capitalize())[0] #the fitting formula Parameters_Names=eval("self."+function.capitalize())[1] ##list of the fitting parameters for i,j in enumerate(Bounds): if Bounds[i][0] != None: Bounds[i][0]=numpy.float32(Bounds[i][0]) if Bounds[i][1] != None: Bounds[i][1]=numpy.float32(Bounds[i][1]) #print Bounds p0 = Parameters() # do fit, here with leastsq model if Model == False: for i,j in enumerate(Parameters_Names): #For each paramters, you can set value, min & max. i.e. p0.add('omega', value= 0.0, min=-numpy.pi/2., max=numpy.pi/2) if j != '0': if Bounds[i][0] != None and Bounds[i][1]!=None: p0.add(j,value=Guess[i],min=Bounds[i][0],max=Bounds[i][1]) elif Bounds[i][0] !=None and Bounds[i][1]==None: p0.add(j,value=Guess[i],min=Bounds[i][0]) elif Bounds[i][0] == None and Bounds[i][1] != None: p0.add(j,value=Guess[i],max=Bounds[i][1]) else: p0.add(j,value=Guess[i]) print 'Fitting in process ...' try: result = minimize(Function, p0, args=(X, Source)) RenderingX=numpy.linspace(float(X[0]),float(X[-1]),num=Number_of_points) fit = Function(result.params,RenderingX) #Rendering, with Popt, the best fitting parameters except: print 'Fitting failed, try other parameters or constraints' return print 'Fitting performed between points ',StartP,' and ',EndP, ' (',len(X),' points)' print 'in units between: ',StartX,' and ',EndX print '######### FITTING RESULTS ############' print 'Parameters are :' res=[] for i in list(result.params): print i, result.params[i].value res.append(result.params[i].value) elif Model== True: for i,j in enumerate(Parameters_Names): if j != '0': p0.add(j,value=Guess[i]) RenderingX=numpy.linspace(float(X[0]),float(X[-1]),num=Number_of_points) fit = Function(p0,RenderingX) #Rendering, with Popt, the best fitting parameters # if Show_Parameters == True: # for i in range(len(popt)): # if List[i][0] != '0': # try: # pyplot.text(begin+((end-begin)/10), max(fit)-(i+1)*abs((max(fit)-min(fit))/(10)), r"%s = {%s} +/- {%s}" % ((str(List[i][0])),str(float(popt[i])),str(float((pcov[i][i])**0.5))))# .format(popt[i], (pcov[i][i])**0.5)) # except: # pyplot.text(begin+((end-begin)/10), max(fit)-(i+1)*abs((max(fit)-min(fit))/(10)),'test') #if Show_Error_Bars == True: to do #pyplot.errorbar(X, Source, yerr = y_sigma, fmt = 'o') # if Show_Guess == True: # guess=Function(X,*p0) # G,=pyplot.plot(X, guess, label='Test data',marker='o',color='g') # if RAW_Data == True: # pyplot.legend([S, G, F], ["Data", "initial guess", "Fit"], loc='best',fancybox=True) # else: # pyplot.legend([G, F], ["initial guess", "Fit"], loc='best',fancybox=True) # else: # if RAW_Data == True: # pyplot.legend([S, F], ["Data", "Fit"], loc='best',fancybox=True) # else: # pyplot.legend([F], ["Fit"], loc='best',fancybox=True) if Rendering == True: pyplot.rc('axes',fc='white') if Figure == None: #Creation of the figure. If Figure is not None, the fit is integrated in pre-existing figure fig=pyplot.figure(facecolor='white') else: fig = Figure pyplot.title('Fitting completed') if RAW_Data == True: S,=pyplot.plot(X, Source,color='b') try: if Show_Residuals == True: final = Source + result.residual pyplot.plot(X, final, 'r') except UnboundLocalError: #Should be only in the Plugin, at first launch. print 'No results' F,=pyplot.plot(RenderingX, fit, linestyle='--',color=Color) pyplot.xlim([begin,end]) pyplot.grid(True) pyplot.show() return fit,res,fig else: return fit
def main(input_one, input_two, output_name): trackone = audio.LocalAudioFile(input_one) tracktwo = audio.LocalAudioFile(input_two) sectionsone, segmentsone = trackone.analysis.sections, trackone.analysis.segments fsegsone, i = [], 0 for section in sectionsone: while segmentsone[i].start + segmentsone[i].duration < section.start: i = i + 1 fsegsone.append(segmentsone[i]) sectionstwo, segmentstwo = tracktwo.analysis.sections, tracktwo.analysis.segments fsegstwo, i = [], 0 for section in sectionstwo: while segmentstwo[i].start + segmentstwo[i].duration < section.start: i = i + 1 fsegstwo.append(segmentstwo[i]) ssmone, ssmtwo, ssmonetwo = [], [], [] for i in range(len(sectionsone)): p1, t1, lb1, lm1, d1 = fsegsone[i].pitches, fsegsone[i].timbre, fsegsone[i].loudness_begin, fsegsone[i].loudness_max, fsegsone[i].duration tp1, k1, m1, ts1, ln1 = sectionsone[i].tempo, sectionsone[i].key, sectionsone[i].mode, sectionsone[i].time_signature, sectionsone[i].loudness for j in range(len(sectionsone)): p2, t2, lb2, lm2, d2 = fsegsone[j].pitches, fsegsone[j].timbre, fsegsone[j].loudness_begin, fsegsone[j].loudness_max, fsegsone[j].duration tp2, k2, m2, ts2, ln2 = sectionsone[j].tempo, sectionsone[j].key, sectionsone[j].mode, sectionsone[j].time_signature, sectionsone[j].loudness dp, dt, db, dm, dd = 0, 0, abs(lb2 - lb1), abs(lm2 - lm1), abs(d2 - d1) dtp, dk, dm, dts, dln = abs(tp2 - tp1), min(abs(k2 - k1), 12 - abs(k2 - k1)), abs(m2 - m1), 1/fractions.gcd(ts2, ts1), abs(ln2 - ln1) for k in range(12): dp = dp + (p2[k] - p1[k])**2 dt = dt + (t2[k] - t1[k])**2 dist = (dp**0.5)*10 + (dt**0.5) + db + dm + dd*100 + dtp*10 + dk*100 + dm + dts + dln ssmone.append(dist) for i in range(len(sectionstwo)): p1, t1, lb1, lm1, d1 = fsegstwo[i].pitches, fsegstwo[i].timbre, fsegstwo[i].loudness_begin, fsegstwo[i].loudness_max, fsegstwo[i].duration tp1, k1, m1, ts1, ln1 = sectionstwo[i].tempo, sectionstwo[i].key, sectionstwo[i].mode, sectionstwo[i].time_signature, sectionstwo[i].loudness for j in range(len(sectionstwo)): p2, t2, lb2, lm2, d2 = fsegstwo[j].pitches, fsegstwo[j].timbre, fsegstwo[j].loudness_begin, fsegstwo[j].loudness_max, fsegstwo[j].duration tp2, k2, m2, ts2, ln2 = sectionstwo[j].tempo, sectionstwo[j].key, sectionstwo[j].mode, sectionstwo[j].time_signature, sectionstwo[j].loudness dp, dt, db, dm, dd = 0, 0, abs(lb2 - lb1), abs(lm2 - lm1), abs(d2 - d1) dtp, dk, dm, dts, dln = abs(tp2 - tp1), min(abs(k2 - k1), 12 - abs(k2 - k1)), abs(m2 - m1), 1/fractions.gcd(ts2, ts1), abs(ln2 - ln1) for k in range(12): dp = dp + (p2[k] - p1[k])**2 dt = dt + (t2[k] - t1[k])**2 dist = (dp**0.5)*10 + (dt**0.5) + db + dm + dd*100 + dtp*10 + dk*100 + dm + dts + dln ssmtwo.append(dist) for i in range(len(sectionsone)): p1, t1, lb1, lm1, d1 = fsegsone[i].pitches, fsegsone[i].timbre, fsegsone[i].loudness_begin, fsegsone[i].loudness_max, fsegsone[i].duration tp1, k1, m1, ts1, ln1 = sectionsone[i].tempo, sectionsone[i].key, sectionsone[i].mode, sectionsone[i].time_signature, sectionsone[i].loudness for j in range(len(sectionstwo)): p2, t2, lb2, lm2, d2 = fsegstwo[j].pitches, fsegstwo[j].timbre, fsegstwo[j].loudness_begin, fsegstwo[j].loudness_max, fsegstwo[j].duration tp2, k2, m2, ts2, ln2 = sectionstwo[j].tempo, sectionstwo[j].key, sectionstwo[j].mode, sectionstwo[j].time_signature, sectionstwo[j].loudness dp, dt, db, dm, dd = 0, 0, abs(lb2 - lb1), abs(lm2 - lm1), abs(d2 - d1) dtp, dk, dm, dts, dln = abs(tp2 - tp1), min(abs(k2 - k1), 12 - abs(k2 - k1)), abs(m2 - m1), 1/fractions.gcd(ts2, ts1), abs(ln2 - ln1) for k in range(12): dp = dp + (p2[k] - p1[k])**2 dt = dt + (t2[k] - t1[k])**2 dist = (dp**0.5)*10 + (dt**0.5) + db + dm + dd*100 + dtp*10 + dk*100 + dm + dts + dln ssmonetwo.append(dist) ssmone = numpy.array(ssmone).reshape(len(fsegsone), len(fsegsone)) ssmtwo = numpy.array(ssmtwo).reshape(len(fsegstwo), len(fsegstwo)) ssmonetwo = numpy.array(ssmonetwo).reshape(len(fsegsone), len(fsegstwo)) plt.imshow(ssmone, 'gray') plt.title('Section Distance Within ' + input_one) plt.colorbar() plt.savefig(output_name+'_one') plt.show() plt.imshow(ssmtwo, 'gray') plt.title('Section Distance Within ' + input_two) plt.colorbar() plt.savefig(output_name+'_two') plt.show() plt.imshow(ssmonetwo, 'gray') plt.title('Section Distance Between ' + input_one + ' and ' + input_two) plt.colorbar() plt.savefig(output_name+'_onetwo') plt.show()
def ScaleAxis(self): self.Sorted_X_Coordinates_Scaled=numpy.array(self.Sorted_X_Coordinates)*self.Scaling_Factor self.Sorted_Y_Coordinates_Scaled=numpy.array(self.Sorted_Y_Coordinates)*self.Scaling_Factor
def on_listWidgetFiles_dropped(self, filePaths): self.FileType=None #TODO : Add wcp and igor SweepA # Solve missing sweep bug. (counter will not increment) for filePath in filePaths: if os.path.exists(filePath): Array,Var=self.IgorLoad(filePath) if Array == None and Var == None: return Suggestion=self.Suggest(Array) #Find the most likely suggestion for filter Filter,ok = QtGui.QInputDialog.getText(Main.FilteringWidget, 'To filter names, add text here', "",QtGui.QLineEdit.Normal,Suggestion) #Split Filter if multiple inputs detected if ';' in Filter: Filter = Filter.split(';') else: Filter=[str(Filter)] #Split Filter if multiple inputs detected tempkeys=[] for i in Array: tempkeys.append(i) tempkeys=sorted(tempkeys, key=self.splitgroups) #Detect the number of channels NewFilterList=[] for s in tempkeys: #for f in Filter: #if f in s: if s.startswith(tuple(Filter)): NewFilterList.append(''.join([i for i in s if not i.isdigit()])) #NewFilterList=[x for x in NewFilterList if "C_Record" not in x] Requete.NumberofChannels = len(list(set(NewFilterList))) OriginalSweepNames=[] FormatedSweepNames=[] for Filter in list(set(NewFilterList)): counter=0 for originalName in tempkeys: if Filter in originalName: if len(Navigate.ArrayList) <= counter: Navigate.ArrayList.append([]) formatedName=originalName Main.LoadedList.append(originalName) if "Record" in Filter: shortname=originalName[originalName.index('d')+2:] shortname=shortname.zfill(4) formatedName=Filter+shortname self.FileType="Neuromatic" elif "sweep" in Filter: shortname=originalName[originalName.index('p')+2:] shortname=shortname.zfill(4) formatedName=Filter+shortname self.FileType="Synaptics" else: wcp=False for letter in list(string.ascii_uppercase): if Filter == letter: wcp=True shortname=originalName[originalName.index(letter)+1:] shortname=shortname.zfill(4) formatedName=letter+shortname self.FileType="WinWCP" if wcp == False: print 'Filetype not supported yet or not tested' return OriginalSweepNames.append(originalName) FormatedSweepNames.append(formatedName) exec("Analysis."+formatedName+"= Array[originalName]") Navigate.ArrayList[counter].append(numpy.array(eval("Analysis."+formatedName),dtype=float64)) counter+=1 if Var != None: for i in Var: exec("Analysis."+i+"= Var[i]") Navigate.VarList[i]=eval("Analysis."+i) #else: # exec("Analysis.Data = Array") Main.AnalysisWidget.setEnabled(True) Main.NavigationWidget.setEnabled(True) Main.MappingWidget.setEnabled(True) if len(Navigate.ArrayList[0][0]) > 200000: savename, ok = QtGui.QInputDialog.getText(QtCore.QObject().sender().parent(), 'Long file',''' The signal looks very long and could be a concatenated signal or a continuous recording. Do you want to reslice it?''') if ok: print 'more than 200 000 points per sweep, original trace was auto-resliced' if Navigate.VarList.has_key("sampling_rate") == True: sr = int(1000.*Navigate.VarList["sampling_rate"]) elif Navigate.VarList.has_key("SampleInterval") == True: sr = int(1000./Navigate.VarList["SampleInterval"]) else: sr = 50000 counter=0 temp=[None]*int(len(Navigate.ArrayList[0][0])/sr) for Slice in range(len(temp)): temp[Slice]=[None]*Requete.NumberofChannels print 'reslicing slice ',Slice for n in range(Requete.NumberofChannels): temp[Slice][n]=numpy.array(Navigate.ArrayList[0][n][0:sr]) del Navigate.ArrayList[0][n][0:sr] Navigate.ArrayList=temp del temp self.Update_Navigate() Requete.Add_Dictionnary_Arrays() Infos.Actualize() #QtGui.QListWidgetItem(filePath+" added as self."+filePath.split("/")[-1][:-4], self.listWidgetFiles) QtGui.QListWidgetItem(filePath+" opened", self.listWidgetFiles) for i in range(len(OriginalSweepNames)): QtGui.QListWidgetItem(" Igor Wave "+OriginalSweepNames[i]+" loaded as Analysis."+FormatedSweepNames[i], self.listWidgetFiles) Requete.SpikeTrainfromLocal={} Requete.AmpSpikeTrainfromLocal={} Requete.Spiketrain_ids=numpy.copy(Requete.Analogsignal_ids) Main.Current_or_Average.setCurrentIndex(int(Main.Current_or_Average.findText('Navigate.si')))
context.useClock(0, "/#[TYPE=PulseGen]") context.useClock(1, "/#[TYPE=Table]") context.setClock(0, SIMDT) context.setClock(1, SIMDT) context.reset() context.step(RUNTIME) plot0.dumpFile("pulse0.plot") plot1.dumpFile("pulse1.plot") plot2.dumpFile("pulse2.plot") plotGate.dumpFile("gate.plot") plotTrig.dumpFile("trig.plot") if has_pylab: fig = pylab.figure() pylab.subplot(511) pylab.plot(numpy.array(plot0)) pylab.title('Free Run') pylab.subplot(512) pylab.plot(numpy.array(plot1)) pylab.title('Triggered (below)') pylab.subplot(513) pylab.plot(numpy.array(plotTrig)) pylab.title('Free Running Trigger') pylab.subplot(514) pylab.plot(numpy.array(plot2)) pylab.title('Gated (below)') pylab.subplot(515) pylab.plot(numpy.array(plotGate)) pylab.title('Free Running Gate') pylab.show() print '----------------------------------------------------------'