def testExtrinsicAndProjection(self): ''' Try a simple example for extrinsic parameters of a camera. ''' intrinsic = np.array([ [1000, 0, 500, 0], [ 0, 1000, 500, 0], [ 0, 0, 1, 0], ]) rot1 = np.array([ [1,0,0], [0,1,0], [0,0,1], ]) trans1 = np.array([0,0,0]) rot2 = np.array([ [0,0,1], [0,1,0], [1,0,0], ]) trans2 = np.array([1000,1000,0]) ext1 = Reconstruction.extrinsic_matrix(rot1, trans1) ext2 = Reconstruction.extrinsic_matrix(rot2, trans2) P1 = Reconstruction.projection_matrix(ext1, None) P2 = Reconstruction.projection_matrix(ext2, ext1)
def calibrate(self, instance): ''' Calibrates the current instance with another by finding the relative fundamental, essential, and extrinsic matrix. Args: instance (ImageInstance): The other instance to calibrate with. ''' kp1, _ = self.features kp2, _ = instance.features fundamental, self.matches[instance] = Reconstruction.\ estimate_fundamental(kp1, kp2, self.matches[instance]) essential = Reconstruction.essential_from_fund(self.intrinsic, instance.intrinsic, fundamental) rotation, translation = Reconstruction.extract_relative_pos(essential) extrinsic = Reconstruction.extrinsic_matrix(rotation, translation) # Store information in relative calibration dict entry calibration_info = dict() calibration_info['essential'] = essential calibration_info['fundamental'] = fundamental calibration_info['rotation'] = rotation calibration_info['translation'] = translation calibration_info['extrinsic'] = extrinsic self.calibration[instance] = calibration_info
def Diff_FSPM(): ''' Diff-FSPM 算法分为如下3个步骤: - 原始序列数据集局部转换 - 获取最优序列长度 l_opt ok - 截断原始序列数据集 ok - 层次遍历构建绕动闭前缀序列树 - min_sup 约束剪枝 - 闭等价关系 剪枝 - 预测计数值 PK. 噪音计数值 - 描述上是挖掘FSP树, 实际直接输出结果集 @summary: Diff-FSPM algorithm ''' dplog.info( " === Phase 1: Decomposing input sequence dataset to n-grams (%d<=n<=%d) Begin ===" % (1, conf.l_opt) ) conf.l_opt = GetOptSeqLength(conf.dataset, conf.epsilon, mechanism="Exponential") ngram_set = NGramSet( int(conf.l_opt), N_max=int(conf.n_max) ) ngram_set.load_dataset( conf.dataset, conf.dataset_ngrams % (conf.l_opt) ) dplog.info( " === Phase 1: Decomposing input sequence dataset to n-grams (%d<=n<=%d) End ===" % (1, conf.l_opt) ) dplog.info( " === Phase 2: Sanitizing n-grams to build noisy frequent sequential patterns Tree Begin ===" ) ngram_set = Sanitizer.ngram( ngram_set, conf.n_max, conf.epsilon, conf.l_opt, conf.min_sup) ngram_set.dump( conf.dataset_noisy % (conf.l_opt, conf.epsilon)) dplog.info( " === Phase 2: Sanitizing n-grams to build noisy frequent sequential patterns Tree End ===" ) dplog.info( " === Phase 3: Synthetic frequent sequential patterns from santized n-grams Begin ===" ) factory = Reconstruction( ngram_set, conf.min_sup ) factory.extend() factory.ngramset.dump( conf.dataset_result % (conf.l_opt, conf.epsilon)) dplog.info( " === Phase 3: Synthetic frequent sequential patterns from santized n-grams End ===" )
def testExtrinsicAndProjection(self): ''' Try a simple example for extrinsic parameters of a camera. ''' intrinsic = np.array([ [1000, 0, 500, 0], [0, 1000, 500, 0], [0, 0, 1, 0], ]) rot1 = np.array([ [1, 0, 0], [0, 1, 0], [0, 0, 1], ]) trans1 = np.array([0, 0, 0]) rot2 = np.array([ [0, 0, 1], [0, 1, 0], [1, 0, 0], ]) trans2 = np.array([1000, 1000, 0]) ext1 = Reconstruction.extrinsic_matrix(rot1, trans1) ext2 = Reconstruction.extrinsic_matrix(rot2, trans2) P1 = Reconstruction.projection_matrix(ext1, None) P2 = Reconstruction.projection_matrix(ext2, ext1)
def test_minmod(u, extents, dim): def minmod(a, b): if a * b <= 0.0: return 0.0 if abs(a) < abs(b): return a return b def compute_face_values(recons_upper_of_cell, recons_lower_of_cell, v, i, j, k, dim_to_recons): if dim_to_recons == 0: slope = minmod(v[i, j, k] - v[i - 1, j, k], v[i + 1, j, k] - v[i, j, k]) recons_lower_of_cell.append(v[i, j, k] - 0.5 * slope) recons_upper_of_cell.append(v[i, j, k] + 0.5 * slope) if dim_to_recons == 1: slope = minmod(v[i, j, k] - v[i, j - 1, k], v[i, j + 1, k] - v[i, j, k]) recons_lower_of_cell.append(v[i, j, k] - 0.5 * slope) recons_upper_of_cell.append(v[i, j, k] + 0.5 * slope) if dim_to_recons == 2: slope = minmod(v[i, j, k] - v[i, j, k - 1], v[i, j, k + 1] - v[i, j, k]) recons_lower_of_cell.append(v[i, j, k] - 0.5 * slope) recons_upper_of_cell.append(v[i, j, k] + 0.5 * slope) return Reconstruction.reconstruct(u, extents, dim, [1, 1, 1], compute_face_values)
def test_monotised_central(u, extents, dim): def monotised_central(a, b): sign = lambda x: -1 if x < 0 else 1 sign_a = sign(a) sign_b = sign(b) return 0.5 * (sign_a + sign_b) * min(0.5 * abs(a + b), min(2.0 * abs(a), 2.0 * abs(b))) def compute_face_values(recons_upper_of_cell, recons_lower_of_cell, v, i, j, k, dim_to_recons): if dim_to_recons == 0: slope = monotised_central(v[i, j, k] - v[i - 1, j, k], v[i + 1, j, k] - v[i, j, k]) recons_lower_of_cell.append(v[i, j, k] - 0.5 * slope) recons_upper_of_cell.append(v[i, j, k] + 0.5 * slope) if dim_to_recons == 1: slope = monotised_central(v[i, j, k] - v[i, j - 1, k], v[i, j + 1, k] - v[i, j, k]) recons_lower_of_cell.append(v[i, j, k] - 0.5 * slope) recons_upper_of_cell.append(v[i, j, k] + 0.5 * slope) if dim_to_recons == 2: slope = monotised_central(v[i, j, k] - v[i, j, k - 1], v[i, j, k + 1] - v[i, j, k]) recons_lower_of_cell.append(v[i, j, k] - 0.5 * slope) recons_upper_of_cell.append(v[i, j, k] + 0.5 * slope) return Reconstruction.reconstruct(u, extents, dim, [1, 1, 1], compute_face_values)
def triangulate_points(self, instance): ''' Finds the depth map of the image using calibration information from another image. Args: instance (ImageInstance): The other instance to triangulate from. Returns: numpy.ndarray, triangulated points in the world. ''' rows, cols, _ = self.img.shape # Find corresponding points between images correspondences = Reconstruction.find_correspondences(self.img, instance.img, self.calibration[instance]['fundamental'], self.transforms[instance]) pts1 = np.float32( [key for key, val in correspondences.iteritems()] ).reshape(-1, 1, 2) pts2 = np.float32( [val for key, val in correspondences.iteritems()] ).reshape(-1, 1, 2) # Triangulate points from correspondences P1 = np.hstack( (np.eye(3), np.zeros((3,1))) ) P2 = self.calibration[instance]['extrinsic'] points = Reconstruction.triangulate_points(pts1, pts2, P1, P2, self.intrinsic) # Create depth map depth = np.empty((rows, cols)) depth.fill(np.min(points[:,-1])) skip = sfm.CORRESPONDENCE_SKIP for idx, pos in enumerate(correspondences.iteritems()): x,y = pos[0] depth[y:y+skip,x:x+skip] = points[idx][-1] return points, depth
def triangulate_points(self, instance): ''' Finds the depth map of the image using calibration information from another image. Args: instance (ImageInstance): The other instance to triangulate from. Returns: numpy.ndarray, triangulated points in the world. ''' rows, cols, _ = self.img.shape # Find corresponding points between images correspondences = Reconstruction.find_correspondences( self.img, instance.img, self.calibration[instance]['fundamental'], self.transforms[instance]) pts1 = np.float32([key for key, val in correspondences.iteritems() ]).reshape(-1, 1, 2) pts2 = np.float32([val for key, val in correspondences.iteritems() ]).reshape(-1, 1, 2) # Triangulate points from correspondences P1 = np.hstack((np.eye(3), np.zeros((3, 1)))) P2 = self.calibration[instance]['extrinsic'] points = Reconstruction.triangulate_points(pts1, pts2, P1, P2, self.intrinsic) # Create depth map depth = np.empty((rows, cols)) depth.fill(np.min(points[:, -1])) skip = sfm.CORRESPONDENCE_SKIP for idx, pos in enumerate(correspondences.iteritems()): x, y = pos[0] depth[y:y + skip, x:x + skip] = points[idx][-1] return points, depth
def match_features(self, instance): ''' Matches features to another image and computes relevant matrices. Args: instance (ImageInstance): The image to match to. ''' kp1, des1 = self.features kp2, des2 = instance.features matches = Reconstruction.find_matches(kp1, des1, kp2, des2) matches, xform = Reconstruction.find_inliers(kp1, kp2, matches) self.matches[instance] = matches self.transforms[instance] = xform # Perform calibration as well self.calibrate(instance)
def testFundamentalEssential(self): ''' Check that the fundamental and essential matrix equations are equivalent. ''' kp1, _ = self.instances[0].features kp2, _ = self.instances[1].features matches = self.instances[0].matches[self.instances[1]] fund, _ = Reconstruction.estimate_fundamental(kp1, kp2, matches) esst = Reconstruction.essential_from_fund( self.instances[0].intrinsic, self.instances[1].intrinsic, fund, ) fund2 = Reconstruction.fundamental_from_esst( self.instances[0].intrinsic, self.instances[1].intrinsic, esst, ) self.assertTrue( self.checkArrays(fund, fund2) )
def testFundamentalEssential(self): ''' Check that the fundamental and essential matrix equations are equivalent. ''' kp1, _ = self.instances[0].features kp2, _ = self.instances[1].features matches = self.instances[0].matches[self.instances[1]] fund, _ = Reconstruction.estimate_fundamental(kp1, kp2, matches) esst = Reconstruction.essential_from_fund( self.instances[0].intrinsic, self.instances[1].intrinsic, fund, ) fund2 = Reconstruction.fundamental_from_esst( self.instances[0].intrinsic, self.instances[1].intrinsic, esst, ) self.assertTrue(self.checkArrays(fund, fund2))
print "\n=== Phase 2.1: Sanitizing clos_n-grams\n" ngram_set = Sanitizer.Equivalence( ngram_set, output_dir + dataset_name + "-" + str(scale) + "-original-" + str(n_max) + "grams.dat", output_dir + dataset_name + "-" + str(scale) + "-original-" + str(n_max) + "_clo_grams.dat") print "\n=== Phase 2.2: Sanitizing n-grams\n" ngram_set = Sanitizer.ngram(ngram_set, n_max, budget=epsilon, sensitivity=l_max) ngram_set.dump(output_dir + dataset_name + file_id + ".dat") print "\n=== Phase 3: Synthetic sequential database generation from sanitized n-grams\n" factory = Reconstruction(ngram_set, lUp) # Reconstruct longer grams from shorter ones using the Markov approach factory.extend() # Saving the extended ngramset factory.ngramset.dump(outdataset_name_info % (scale, n_max, topN, lLeft, lUp, deta, epsilon) + "-extended.dat") # Generating dataset factory.reconstruct(outdataset_name_info % (scale, n_max, topN, lLeft, lUp, deta, epsilon) + "-reconstructed.dat") print "\n=== Phase 4: Get Consolidated Frequency"
def __init__(self): self.root = Tkinter.Tk() self.root.wm_title("Test Bench Dashboard") self.top = None self.topplot = None self.topcanvas = None self.topcbar = None self.topcbaxes = None menu = Tkinter.Menu(self.root) self.root.config(menu=menu) filemenu = Menu(menu) menu.add_cascade(label="File", menu=filemenu) filemenu.add_command(label="Exit", command=self.root.quit) viewmenu = Menu(menu) menu.add_cascade(label="View", menu=viewmenu) viewmenu.add_command(label="Dedicated Reconstruction Window", command=self.Eitwin) viewmenu.add_separator() viewmenu.add_command(label="something else", command=self.Something_else) helpmenu = Menu(menu) menu.add_cascade(label="Help", menu=helpmenu) helpmenu.add_command(label="About...", command=self.About) self.root.protocol("WM_DELETE_WINDOW", self.quit) # make Esc exit the program self.root.bind('<Escape>', lambda e: self.root.destroy()) # Matplotlibbing. fig = mpl.figure.Figure(figsize=(5, 4), dpi=100) # pos = [left, bottom, width, height] image_position = [0.1, 0.25, 0.7, 0.7] histogram_position = [0.1, 0.08, 0.8, 0.1] colorbar_position = [0.85, 0.25, 0.03, 0.7] self.imageplt = fig.add_axes(image_position) self.histplt = fig.add_axes(histogram_position) self.cbaxes = fig.add_axes(colorbar_position) # 180,225,270,315,0,45,90,135 # 1,2,3,4,5,6,7,8 # Add text for electrode locations. self.imageplt.annotate('180d(AFE1)', xy=(0.4, 0.9), xycoords='axes fraction') self.imageplt.annotate('225d(AFE2)', xy=(0.15, 0.75), xycoords='axes fraction') self.imageplt.annotate('270d(AFE3)', xy=(0.0, 0.5), xycoords='axes fraction') self.imageplt.annotate('315d(AFE4)', xy=(0.2, 0.2), xycoords='axes fraction') self.imageplt.annotate('0d(AFE5)', xy=(0.5, 0.1), xycoords='axes fraction') self.imageplt.annotate('45d(AFE6)', xy=(0.75, 0.25), xycoords='axes fraction') self.imageplt.annotate('90d(AFE7)', xy=(0.9, 0.5), xycoords='axes fraction') self.imageplt.annotate('135d(AFE8)', xy=(0.8, 0.8), xycoords='axes fraction') ypadding = 10 xpadding = 20 # # self.file_marker = 0 self.file_name = '' self.data_file_array = [] # Will this often need to be changed? scale_max = 90000 self.sliders = [0, scale_max, 0, scale_max] min_cbar = 0 max_cbar = scale_max scale_tick_interval = float(scale_max / 10) # intialize the reconstruction library. self.image_reconstruct = eit.Reconstruction() self.img = self.image_reconstruct.img self.plot = self.imageplt.imshow(self.img, interpolation='nearest') # self.imageplt.set_position(image_position) # set a new position # self.histplt.set_position(histogram_position) self.cbar = mpl.pyplot.colorbar(self.plot, cax=self.cbaxes) # self.cbar = mpl.pyplot.colorbar(self.imageplt,cax = self.cbaxes) self.cbar.set_clim([min_cbar, max_cbar]) # self.canvas = mpl.backends.backend_tkagg.FigureCanvasTkAgg( fig, master=self.root) self.canvas.show() self.canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1) toolbar = mpl.backends.backend_tkagg.NavigationToolbar2TkAgg( self.canvas, self.root) toolbar.update() self.canvas._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1) # canvas.mpl_connect('key_press_event', on_key_event) self.use_blit = False # cache the background, in the init. if self.use_blit: # cache the background. self.background = self.canvas.copy_from_bbox(self.imageplt.bbox) self.histbackground = self.canvas.copy_from_bbox(self.histplt.bbox) self.cbbackground = self.canvas.copy_from_bbox(self.cbaxes.bbox) self.total_rendering_time = 0.0 self.total_processing_time = 0.0 # --------------- # defining frames # --------------- bottomframe0 = Frame(self.root) bottomframe1 = Frame(self.root) bottomframe2 = Frame(self.root) bottomframe3 = Frame(self.root) bottomframe0.pack(side=TOP) bottomframe1.pack(side=TOP) bottomframe2.pack(side=TOP) bottomframe3.pack(side=TOP) # This is the text box... self.msg = Tkinter.Text(bottomframe0, height=1.0, bg="light cyan", state=Tkinter.NORMAL) self.msg.grid(row=1, column=0, columnspan=3) self.msg.pack(fill="x", expand=True) # sliders. self.w1 = Tkinter.Scale(bottomframe0, from_=self.sliders[0], to=self.sliders[1], length=600, tickinterval=scale_tick_interval, orient=HORIZONTAL, label='MIN') self.w1.set(scale_max / 10) self.w1.pack(fill="x", expand=True) self.w2 = Tkinter.Scale(bottomframe0, from_=self.sliders[2], to=self.sliders[3], length=600, tickinterval=scale_tick_interval, orient=HORIZONTAL, label='MAX') self.w2.set(9 * scale_max / 10) self.w2.pack(fill="x", expand=True) # Text entry boxes for min and max range of each slider bar. # # cbarbut = Tkinter.Button(bottomframe0, text='Update HIST', command=self.update_hist) cbarbut.pack(side=Tkinter.RIGHT, padx=3, pady=ypadding) cbarbut = Tkinter.Button(bottomframe0, text='Update CBAR', command=self.update_cbar) cbarbut.pack(side=Tkinter.RIGHT, padx=3, pady=ypadding) self.hist_update = False self.min_slider_l = Tkinter.Entry(bottomframe0) self.min_slider_h = Tkinter.Entry(bottomframe0) self.max_slider_l = Tkinter.Entry(bottomframe0) self.max_slider_h = Tkinter.Entry(bottomframe0) self.max_slider_h.pack(side=Tkinter.RIGHT, padx=3, pady=ypadding) self.max_slider_h_label = Tkinter.Label( bottomframe0, text="max_h:").pack(side=Tkinter.RIGHT) self.max_slider_l.pack(side=Tkinter.RIGHT, padx=3, pady=ypadding) self.max_slider_l_label = Tkinter.Label( bottomframe0, text="max_l:").pack(side=Tkinter.RIGHT) self.min_slider_h.pack(side=Tkinter.RIGHT, padx=3, pady=ypadding) self.min_slider_h_label = Tkinter.Label( bottomframe0, text="min_h:").pack(side=Tkinter.RIGHT) self.min_slider_l.pack(side=Tkinter.RIGHT, padx=3, pady=ypadding) self.min_slider_l_label = Tkinter.Label( bottomframe0, text="min_l:").pack(side=Tkinter.RIGHT) self.min_slider_l.bind("<Return>", self.evaluate) self.min_slider_h.bind("<Return>", self.evaluate) self.max_slider_l.bind("<Return>", self.evaluate) self.max_slider_h.bind("<Return>", self.evaluate) full_ports = list(serial.tools.list_ports.comports()) portnames = [item[0] for item in full_ports] if len(portnames) > 0: self.menuselect = StringVar(self.root) self.menuselect.set(portnames[0]) # apply has been deprecated. # listboxdataconnect = apply(OptionMenu, (self.root, self.menuselect) + tuple(portnames )) listboxdataconnect = OptionMenu(*(self.root, self.menuselect) + tuple(portnames)) listboxdataconnect.pack(in_=bottomframe1, side=Tkinter.LEFT, padx=3, pady=ypadding) self.baselinebut = Tkinter.Button(master=bottomframe1, text="Baseline", command=self.baseline) self.baselinebut.pack(side=Tkinter.RIGHT, padx=3, pady=ypadding) self.recorddata = Tkinter.Button(master=bottomframe1, text='Record', command=self.record) self.recorddata.pack(side=Tkinter.RIGHT, padx=3, pady=ypadding) self.buttonconnect = Tkinter.Button(master=bottomframe1, text='Connect', command=self.connect) self.buttonconnect.pack(side=Tkinter.RIGHT, padx=3, pady=ypadding) else: # no serial port detected. print('no serial port found, hope that\'s OK') self.text = "no serial port found, hope that's OK" if expertMode is False: tkMessageBox.showwarning( "No serial port", "No device detected\nCheck cable and connection") readfilerunbut = Tkinter.Button(bottomframe2, text='Run', command=self.run_file) readfilerunbut.pack(side=Tkinter.RIGHT, padx=3, pady=ypadding) readfilestartbut = Tkinter.Button(bottomframe2, text='Step', command=self.step_file) readfilestartbut.pack(side=Tkinter.RIGHT, padx=3, pady=ypadding) readfilebut = Tkinter.Button(bottomframe2, text='ReadFromFile', command=self.load_file) readfilebut.pack(side=Tkinter.RIGHT, padx=3, pady=ypadding) # start Serial handler off in a separate process. self.s = Serialhandler.Serialhandler() self.s.start() self.s.join() self.text = 'hi' self.root.after(200, self.process_data) self.root.mainloop()
def test_aoweno53(u, extents, dim): gamma_hi = 0.85 gamma_lo = 0.999 epsilon = 1.0e-12 exponent = 8 def aoweno53(q): j = 2 moments_sr3_1 = [ 1.041666666666666 * q[j] - 0.08333333333333333 * q[j - 1] + 0.04166666666666666 * q[j - 2], 0.5 * q[j - 2] - 2.0 * q[j - 1] + 1.5 * q[j], 0.5 * q[j - 2] - q[j - 1] + 0.5 * q[j] ] moments_sr3_2 = [ 0.04166666666666666 * q[j + 1] + 0.9166666666666666 * q[j] + 0.04166666666666666 * q[j - 1], 0.5 * (q[j + 1] - q[j - 1]), 0.5 * q[j - 1] - q[j] + 0.5 * q[j + 1] ] moments_sr3_3 = [ 0.04166666666666666 * q[j + 2] - 0.08333333333333333 * q[j + 1] + 1.04166666666666666 * q[j], -1.5 * q[j] + 2.0 * q[j + 1] - 0.5 * q[j + 2], 0.5 * q[j] - q[j + 1] + 0.5 * q[j + 2] ] moments_sr5 = [ -2.95138888888888881e-03 * q[j - 2] + 5.34722222222222196e-02 * q[j - 1] + 8.98958333333333304e-01 * q[j] + 5.34722222222222196e-02 * q[j + 1] + -2.95138888888888881e-03 * q[j + 2], 7.08333333333333315e-02 * q[j - 2] + -6.41666666666666718e-01 * q[j - 1] + 6.41666666666666718e-01 * q[j + 1] + -7.08333333333333315e-02 * q[j + 2], -3.27380952380952397e-02 * q[j - 2] + 6.30952380952380931e-01 * q[j - 1] + -1.19642857142857140e+00 * q[j] + 6.30952380952380931e-01 * q[j + 1] + -3.27380952380952397e-02 * q[j + 2], -8.33333333333333287e-02 * q[j - 2] + 1.66666666666666657e-01 * q[j - 1] + -1.66666666666666657e-01 * q[j + 1] + 8.33333333333333287e-02 * q[j + 2], 4.16666666666666644e-02 * q[j - 2] + -1.66666666666666657e-01 * q[j - 1] + 2.50000000000000000e-01 * q[j] + -1.66666666666666657e-01 * q[j + 1] + 4.16666666666666644e-02 * q[j + 2] ] beta_r3_1 = moments_sr3_1[1]**2 + 37.0 / 3.0 * moments_sr3_1[2]**2 beta_r3_2 = moments_sr3_2[1]**2 + 37.0 / 3.0 * moments_sr3_2[2]**2 beta_r3_3 = moments_sr3_3[1]**2 + 37.0 / 3.0 * moments_sr3_3[2]**2 beta_sr5 = (moments_sr5[1]**2 + 61.0 / 5.0 * moments_sr5[1] * moments_sr5[3] + 37.0 / 3.0 * moments_sr5[2]**2 + 1538.0 / 7.0 * moments_sr5[2] * moments_sr5[4] + 8973.0 / 50.0 * moments_sr5[3]**2 + 167158.0 / 49.0 * moments_sr5[4]**2) linear_weights = [ gamma_hi, 0.5 * (1.0 - gamma_hi) * (1.0 - gamma_lo), (1.0 - gamma_hi) * gamma_lo, 0.5 * (1.0 - gamma_hi) * (1.0 - gamma_lo) ] nonlinear_weights = np.asarray([ linear_weights[0] / (beta_sr5 + epsilon)**exponent, linear_weights[1] / (beta_r3_1 + epsilon)**exponent, linear_weights[2] / (beta_r3_2 + epsilon)**exponent, linear_weights[3] / (beta_r3_3 + epsilon)**exponent ]) normalization = np.sum(nonlinear_weights) nonlinear_weights = nonlinear_weights / normalization moments = np.asarray([ nonlinear_weights[0] / linear_weights[0] * (moments_sr5[0] - linear_weights[1] * moments_sr3_1[0] - linear_weights[2] * moments_sr3_2[0] - linear_weights[3] * moments_sr3_3[0]) + nonlinear_weights[1] * moments_sr3_1[0] + nonlinear_weights[2] * moments_sr3_2[0] + nonlinear_weights[3] * moments_sr3_3[0], nonlinear_weights[0] / linear_weights[0] * (moments_sr5[1] - linear_weights[1] * moments_sr3_1[1] - linear_weights[2] * moments_sr3_2[1] - linear_weights[3] * moments_sr3_3[1]) + nonlinear_weights[1] * moments_sr3_1[1] + nonlinear_weights[2] * moments_sr3_2[1] + nonlinear_weights[3] * moments_sr3_3[1], nonlinear_weights[0] / linear_weights[0] * (moments_sr5[2] - linear_weights[1] * moments_sr3_1[2] - linear_weights[2] * moments_sr3_2[2] - linear_weights[3] * moments_sr3_3[2]) + nonlinear_weights[1] * moments_sr3_1[2] + nonlinear_weights[2] * moments_sr3_2[2] + nonlinear_weights[3] * moments_sr3_3[2], nonlinear_weights[0] / linear_weights[0] * moments_sr5[3], nonlinear_weights[0] / linear_weights[0] * moments_sr5[4] ]) polys_at_plus_half = np.asarray( [1.0, 0.5, 0.16666666666666666, 0.05, 0.014285714285714289]) polys_at_minus_half = np.asarray( [1.0, -0.5, 0.16666666666666666, -0.05, 0.014285714285714289]) return [ np.sum(moments * polys_at_minus_half), np.sum(moments * polys_at_plus_half) ] def compute_face_values(recons_upper_of_cell, recons_lower_of_cell, v, i, j, k, dim_to_recons): if dim_to_recons == 0: lower, upper = aoweno53( np.asarray([ v[i - 2, j, k], v[i - 1, j, k], v[i, j, k], v[i + 1, j, k], v[i + 2, j, k] ])) recons_lower_of_cell.append(lower) recons_upper_of_cell.append(upper) if dim_to_recons == 1: lower, upper = aoweno53( np.asarray([ v[i, j - 2, k], v[i, j - 1, k], v[i, j, k], v[i, j + 1, k], v[i, j + 2, k] ])) recons_lower_of_cell.append(lower) recons_upper_of_cell.append(upper) if dim_to_recons == 2: lower, upper = aoweno53( np.asarray([ v[i, j, k - 2], v[i, j, k - 1], v[i, j, k], v[i, j, k + 1], v[i, j, k + 2] ])) recons_lower_of_cell.append(lower) recons_upper_of_cell.append(upper) return Reconstruction.reconstruct(u, extents, dim, [2, 2, 2], compute_face_values)