def add_plot(self,data_x,data_y=None,label='',mode='lines+markers',row=1,col=1): """ Definition to add data to the plot. Parameters ---------- data_x : ndarray X axis data to be plotted. data_y : ndarray Y axis data to be plotted. label : str Label of the plot. mode : str Mode for the plot, it can be either lines+markers, lines or markers. """ if type(data_y) == type(None): data_y = np.arange(0,data_x.shape[0]) if np.__name__ == 'cupy': data_x = np.asnumpy(data_x) data_y = np.asnumpy(data_y) self.fig.add_trace( go.Scatter( x=data_x, y=data_y, mode=mode, name=label, ), row=row, col=col )
def polynomial_fit(line_x, line_y, fit_degree=3): """ Definition to fit polynomials to a vector. Parameters ---------- line_x : ndarray Values along X axis. line_y : ndarray Values along Y axis. degree : int Degree of the polynomial fit. Returns ---------- p : numpy.poly1d polynomial fit. """ if np.__name__ == 'numpy': fun_poly = np.polyfit(line_x, line_y, fit_degree) p = np.poly1d(fun_poly) else: import numpy line_x = np.asnumpy(line_x) line_y = np.asnumpy(line_y) fun_poly = numpy.polyfit(line_x, line_y, fit_degree) p = numpy.poly1d(fun_poly) return p
def nufft2(field, fx, fy, size=None, sign=1, eps=10**(-12)): """ """ if np.__name__ == 'cupy': fx = np.asnumpy(fx).astype(np.float64) fy = np.asnumpy(fy).astype(np.float64) image = np.asnumpy(np.copy(field)).astype(np.complex128) else: image = np.copy(field).astype(np.complex128) if type(size) == type(None): result = finufft.nufft2d1(fx.flatten(), fy.flatten(), image.flatten(), image.shape, eps=eps, isign=sign) else: result = finufft.nufft2d1(fx.flatten(), fy.flatten(), image.flatten(), (size[0], size[1]), eps=eps, isign=sign) if np.__name__ == 'cupy': result = np.asarray(result) return result
def add_field(self, field): """ Definition to add a point to the figure. Parameters ---------- field : ndarray Field to be displayed. """ amplitude = calculate_amplitude(field) phase = calculate_phase(field, deg=True) intensity = calculate_intensity(field) if np.__name__ == 'cupy': amplitude = np.asnumpy(amplitude) phase = np.asnumpy(phase) intensity = np.asnumpy(intensity) self.fig.add_trace(go.Heatmap(z=amplitude, colorscale=self.settings['color scale']), row=1, col=1) self.fig.add_trace(go.Heatmap(z=phase, colorscale=self.settings['color scale']), row=1, col=2) self.fig.add_trace(go.Heatmap(z=intensity, colorscale=self.settings['color scale']), row=1, col=3)
def add_field(self,field,row=1,col=1,showscale=False): """ Definition to add a point to the figure. Parameters ---------- field : ndarray Field to be displayed. row : int Row number. col : int Column number. showscale : bool Set True to show color bar. """ amplitude = calculate_amplitude(field) phase = calculate_phase(field,deg=True) intensity = calculate_intensity(field) if np.__name__ == 'cupy': amplitude = np.asnumpy(amplitude) phase = np.asnumpy(phase) intensity = np.asnumpy(intensity) col = (col-1)*(self.settings["sub column no"])+1 if self.settings["show amplitude"] == True: self.fig.add_trace( go.Heatmap( z=amplitude, colorscale=self.settings['color scale'], showscale = showscale ), row=row, col=col ) col += 1 if self.settings["show phase"] == True: self.fig.add_trace( go.Heatmap( z=phase, colorscale=self.settings['color scale'], showscale = showscale ), row=row, col=col ) col += 1 if self.settings["show intensity"] == True: self.fig.add_trace( go.Heatmap( z=intensity, colorscale=self.settings['color scale'], showscale = showscale ), row=row, col=col ) col += 1
def add_line(self,point_start,point_end,row=1,column=1,color='red'): """ Definition to add a ray to the figure. Parameters ---------- point_start : ndarray Starting point(s). point_end : ndarray Ending point(s). row : int Row number of the figure. column : int Column number of the figure. color : str Color of the lune to be drawn. """ if np.__name__ == 'cupy': point_start = np.asnumpy(point_start) point_end = np.asnumpy(point_end) if len(point_start.shape) == 1: point_start = point_start.reshape((1,3)) if len(point_end.shape) == 1: point_end = point_end.reshape((1,3)) if point_start.shape != point_end.shape: print('Size mismatch in line plot. Sizes are {} and {}.'.format(point_start.shape,point_end.shape)) sys.exit() for point_id in range(0,point_start.shape[0]): points = np.array( [ point_start[point_id], point_end[point_id] ] ) points = points.reshape((2,3)) if np.__name__ == 'cupy': points = np.asnumpy(points) self.fig.add_trace( go.Scatter3d( x=points[:,0], y=points[:,1], z=points[:,2], mode='lines', line=dict( width=self.settings["line width"], color=color, ), opacity=self.settings["opacity"] ), row=row, col=column )
def add_surface(self, data_x, data_y, data_z, surface_color, row=1, column=1, label='', mode='lines+markers', opacity=1., contour=False): """ Definition to add data to the plot. Parameters ---------- data_x : ndarray X axis data to be plotted. data_y : ndarray Y axis data to be plotted. data_z : ndarray Z axis data to be plotted. surface_color : ndarray Colors of the surface. label : str Label of the plot. mode : str Mode for the plot, it can be either lines+markers, lines or markers. opacity : float Opacity of the plot. The value must be between one to zero. Zero is fully trasnparent, while one is opaque. """ if np.__name__ == 'cupy': data_x = np.asnumpy(data_x) data_y = np.asnumpy(data_y) data_z = np.asnumpy(data_z) surface_color = np.asnumpy(surface_color) self.fig.add_trace( go.Surface(x=data_x, y=data_y, z=data_z, surfacecolor=surface_color, colorscale=self.settings['color scale'], opacity=opacity, contours={ 'z': { 'show': contour, }, }), row=row, col=column, )
def compare(): wavelength = 0.5 * pow(10, -6) pixeltom = 6 * pow(10, -6) distance = 0.2 propagation_type = 'Bandlimited Angular Spectrum' k = wavenumber(wavelength) sample_field = np.zeros((500, 500), dtype=np.complex64) sample_field[240:260, 240:260] = 1000 random_phase = np.pi * np.random.random(sample_field.shape) sample_field = sample_field * np.cos( random_phase) + 1j * sample_field * np.sin(random_phase) if np.__name__ == 'cupy': sample_field = np.asnumpy(sample_field) sample_field_torch = torch.from_numpy(sample_field) ## Propagate and reconstruct using torch. hologram_torch = propagate_beam_torch(sample_field_torch, k, distance, pixeltom, wavelength, propagation_type) reconstruction_torch = propagate_beam_torch(hologram_torch, k, -distance, pixeltom, wavelength, propagation_type) ## Propagate and reconstruct using np. hologram = propagate_beam(sample_field, k, distance, pixeltom, wavelength, propagation_type) reconstruction = propagate_beam(hologram, k, -distance, pixeltom, wavelength, propagation_type) np.testing.assert_array_almost_equal(hologram_torch.numpy(), hologram, 3)
def add_point(self,point,row=1,column=1,color='red'): """ Definition to add a point to the figure. Parameters ---------- point : ndarray Point(s). row : int Row number of the figure. column : int Column number of the figure. """ if np.__name__ == 'cupy': point = np.asnumpy(point) self.fig.add_trace( go.Scatter3d( x=point[:,0].flatten(), y=point[:,1].flatten(), z=point[:,2].flatten(), mode='markers', marker=dict( size=self.settings["marker size"], color=color, opacity=self.settings["opacity"] ), ), row=row, col=column )
def test(): from odak import np import torch from odak.learn.wave import gerchberg_saxton, produce_phase_only_slm_pattern, calculate_amplitude from odak.tools import save_image wavelength = 0.000000532 dx = 0.0000064 distance = 0.2 input_field = np.zeros((500, 500), dtype=np.complex64) input_field[0::50, :] += 1 iteration_number = 3 if np.__name__ == 'cupy': input_field = np.asnumpy(input_field) input_field = torch.from_numpy(input_field) hologram, reconstructed = gerchberg_saxton(input_field, iteration_number, distance, dx, wavelength, np.pi * 2, 'IR Fresnel') # hologram = produce_phase_only_slm_pattern( # hologram, # 2*np.pi # ) # amplitude = calculate_amplitude(reconstructed) # amplitude = amplitude.numpy() # save_image( # 'output_amplitude_torch.png', # amplitude, # cmin=0, # cmax=np.amax(amplitude) # ) assert True == True
def main(): # Variables to be set. wavelength = 0.5 * pow(10, -6) pixeltom = 6 * pow(10, -6) distance = 0.2 propagation_type = 'Bandlimited Angular Spectrum' k = wavenumber(wavelength) sample_field = np.zeros((500, 500), dtype=np.complex64) sample_field[240:260, 240:260] = 1000 random_phase = np.pi * np.random.random(sample_field.shape) sample_field = sample_field * np.cos( random_phase) + 1j * sample_field * np.sin(random_phase) if np.__name__ == 'cupy': sample_field = np.asnumpy(sample_field) sample_field = torch.from_numpy(sample_field) hologram = propagate_beam_torch(sample_field, k, distance, pixeltom, wavelength, propagation_type) reconstruction = propagate_beam_torch(hologram, k, -distance, pixeltom, wavelength, propagation_type) # reconstruction = np.asarray(reconstruction.numpy()) # sample_field = np.asarray(sample_field.numpy()) # hologram = np.asarray(hologram.numpy()) # from odak.visualize.plotly import detectorshow # detector = detectorshow() # detector.add_field(sample_field) # detector.show() # detector.add_field(hologram) # detector.show() # detector.add_field(reconstruction) # detector.show() assert True == True
def nuifft2(field, fx, fy, size=None, sign=1, eps=10**(-12)): """ A definition to take 2D Adjoint Non-Uniform Fast Fourier Transform (NUFFT). Parameters ---------- field : ndarray Input field. fx : ndarray Frequencies along x axis. fy : ndarray Frequencies along y axis. size : list or ndarray Shape of the NUFFT calculated for an input field. sign : float Sign of the exponential used in NUFFT kernel. eps : float Accuracy of NUFFT. Returns ---------- result : ndarray NUFFT of the input field. """ if np.__name__ == 'cupy': fx = np.asnumpy(fx).astype(np.float64) fy = np.asnumpy(fy).astype(np.float64) image = np.asnumpy(np.copy(field)).astype(np.complex128) else: image = np.copy(field).astype(np.complex128) if type(size) == type(None): result = finufft.nufft2d1(fx.flatten(), fy.flatten(), image.flatten(), image.shape, eps=eps, isign=sign) else: result = finufft.nufft2d1(fx.flatten(), fy.flatten(), image.flatten(), (size[0], size[1]), eps=eps, isign=sign) if np.__name__ == 'cupy': result = np.asarray(result) return result
def resize_image(img, target_size): if np.__name__ == 'cupy': import numpy img = np.asnumpy(img) img = scipy.misc.imresize(img, (target_size[0], target_size[1])) if np.__name__ == 'cupy': img = np.asarray(img) return img
def nuifft2(field, fx, fy, sign=1, eps=10**(-12)): """ """ if np.__name__ == 'cupy': fx = np.asnumpy(fx).astype(np.float64) fy = np.asnumpy(fy).astype(np.float64) image = np.asnumpy(np.copy(field)).astype(np.complex128) else: image = np.copy(field).astype(np.complex128) result = finufft.nufft2d2(fx.flatten(), fy.flatten(), image, eps=eps, isign=sign) result = result.reshape(field.shape) if np.__name__ == 'cupy': result = np.asarray(result) return result
def main(): # Variables to be set. wavelength = 0.5*pow(10,-6) pixeltom = 6*pow(10,-6) distance = 0.2 propagation_type = 'Bandlimited Angular Spectrum' k = wavenumber(wavelength) sample_field = np.zeros((500,500),dtype=np.complex64) sample_field[ 240:260, 240:260 ] = 1000 random_phase = np.pi*np.random.random(sample_field.shape) sample_field = sample_field*np.cos(random_phase)+1j*sample_field*np.sin(random_phase) criterion = torch.nn.MSELoss() if np.__name__ == 'cupy': sample_field = np.asnumpy(sample_field) sample_field = torch.from_numpy(sample_field) hologram = propagate_beam_torch( sample_field, k, distance, pixeltom, wavelength, propagation_type ) hologram.requires_grad = True reconstruction = propagate_beam_torch( hologram, k, -distance, pixeltom, wavelength, propagation_type ) loss = criterion(torch.abs(sample_field), torch.abs(reconstruction)) loss.backward() print(hologram.grad) print('backward successfully') #from odak.visualize.plotly import detectorshow #detector = detectorshow() #detector.add_field(sample_field) #detector.show() #detector.add_field(hologram) #detector.show() #detector.add_field(reconstruction) #detector.show() assert True==True
def test_plano_convex(): import odak.raytracing as raytracer import odak.tools as tools import odak.catalog as catalog end_points = tools.grid_sample( no=[5,5], size=[2.0,2.0], center=[0.,0.,0.], angles=[0.,0.,0.] ) start_point = [0.,0.,-5.] rays = raytracer.create_ray_from_two_points( start_point, end_points ) lens = catalog.plano_convex_lens() normals,distances = lens.intersect(rays) return True from odak import np import plotly import plotly.graph_objs as go if np.__name__ == 'cupy': df = np.asnumpy(normals[:,0]) dx = np.asnumpy(end_points) dy = np.asnumpy(start_point) else: df = normals[:,0] dx = end_points dy = start_point trace0 = go.Scatter3d(x=df[:,0],y=df[:,1],z=df[:,2]) trace1 = go.Scatter3d(x=dx[:,0],y=dx[:,1],z=dx[:,2]) trace2 = go.Scatter3d(x=[dy[0],],y=[dy[1],],z=[dy[2],]) data = [trace0,trace1,trace2] fig = dict(data=data) plotly.offline.plot(fig) assert True==True
def save_image(fn, img, cmin=0, cmax=255): """ Definition to save a Numpy array as an image. Parameters ---------- fn : str Filename. img : ndarray A numpy array with NxMx3 or NxMx1 shapes. cmin : int Minimum value that will be interpreted as 0 level in the final image. cmax : int Maximum value that will be interpreted as 255 level in the final image. Returns ---------- bool : bool True if successful. """ input_img = np.copy(img).astype(np.float) colorflag = False if len(input_img.shape) == 3: if input_img.shape[2] > 1: input_img = input_img[:, :, 0:3] colorflag = True input_img[input_img < cmin] = cmin input_img[input_img > cmax] = cmax input_img /= cmax input_img *= 255 input_img = input_img.astype(np.uint8) if np.__name__ == 'cupy': input_img = np.asnumpy(input_img) if colorflag == True: result_img = Image.fromarray(input_img) elif colorflag == False: result_img = Image.fromarray(input_img).convert("L") result_img.save(fn) return True
def line_spread_function(line): """ Definition to take the gradient of a 1D function. Parameters ---------- line : ndarray 1D array. Returns ---------- result : ndarray Gradient of the given 1D array. """ if np.__name__ == 'cupy': import numpy cache = np.asnumpy(line) result = numpy.gradient(cache) else: result = np.gradient(line) result = np.asarray(result) return result