def test_with_bounding_box(): """ Test the option to evaluate a model respecting its bunding_box. """ p = models.Polynomial2D(2) & models.Polynomial2D(2) m = models.Mapping((0, 1, 0, 1)) | p with NumpyRNGContext(1234567): m.parameters = np.random.rand(12) m.bounding_box = ((3, 9), (1, 8)) x, y = np.mgrid[:10, :10] a, b = m(x, y) aw, bw = m(x, y, with_bounding_box=True) ind = (~np.isnan(aw)).nonzero() assert_allclose(a[ind], aw[ind]) assert_allclose(b[ind], bw[ind]) aw, bw = m(x, y, with_bounding_box=True, fill_value=1000) ind = (aw != 1000).nonzero() assert_allclose(a[ind], aw[ind]) assert_allclose(b[ind], bw[ind]) # test the order of bbox is not reversed for 1D models p = models.Polynomial1D(1, c0=12, c1=2.3) p.bounding_box = (0, 5) assert (p(1) == p(1, with_bounding_box=True))
def test_fitters_with_weights(fitter): """Issue #5737 """ fitter = fitter() if isinstance(fitter, _NLLSQFitter): pytest.xfail("This test is poorly designed and causes issues for " "scipy.optimize.least_squares based fitters") Xin, Yin = np.mgrid[0:21, 0:21] with NumpyRNGContext(_RANDOM_SEED): zsig = np.random.normal(0, 0.01, size=Xin.shape) # Non-linear model g2 = models.Gaussian2D(10, 10, 9, 2, 3) z = g2(Xin, Yin) gmod = fitter(models.Gaussian2D(15, 7, 8, 1.3, 1.2), Xin, Yin, z + zsig) assert_allclose(gmod.parameters, g2.parameters, atol=10 ** (-2)) # Linear model p2 = models.Polynomial2D(3) p2.parameters = np.arange(10)/1.2 z = p2(Xin, Yin) with pytest.warns(AstropyUserWarning, match=r'Model is linear in parameters'): pmod = fitter(models.Polynomial2D(3), Xin, Yin, z + zsig) assert_allclose(pmod.parameters, p2.parameters, atol=10 ** (-2))
def pcf_forward(pcffile, outname): """ Create the **IDT** forward transform from collimator to gwa. """ with open(pcffile) as f: lines = [l.strip() for l in f.readlines()] factors = lines[lines.index('*Factor 2') + 1].split() # factor==1/factor in backward msa2ote direction and factor==factor in sky2detector direction scale = models.Scale(float(factors[0]), name="x_scale") & \ models.Scale(float(factors[1]), name="y_scale") rotation_angle = lines[lines.index('*Rotation') + 1] # The minius sign here is because astropy.modeling has the opposite direction of rotation than the idl implementation rotation = models.Rotation2D(-float(rotation_angle), name='rotation') # Here the model is called "output_shift" but in the team version it is the "input_shift". input_rot_center = lines[lines.index('*InputRotationCentre 2') + 1].split() input_rot_shift = models.Shift(-float(input_rot_center[0]), name='input_x_shift') & \ models.Shift(-float(input_rot_center[1]), name='input_y_shift') # Here the model is called "input_shift" but in the team version it is the "output_shift". output_rot_center = lines[lines.index('*OutputRotationCentre 2') + 1].split() output_rot_shift = models.Shift(float(output_rot_center[0]), name='output_x_shift') & \ models.Shift(float(output_rot_center[1]), name='output_y_shift') degree = int(lines[lines.index('*FitOrder') + 1]) xcoeff_index = lines.index('*xForwardCoefficients 21 2') xlines = lines[xcoeff_index + 1: xcoeff_index + 22] xcoeff_forward = coeffs_from_pcf(degree, xlines) x_poly_forward = models.Polynomial2D(degree, name='x_poly_forward', **xcoeff_forward) ycoeff_index = lines.index('*yForwardCoefficients 21 2') ycoeff_forward = coeffs_from_pcf(degree, lines[ycoeff_index + 1: ycoeff_index + 22]) y_poly_forward = models.Polynomial2D(degree, name='y_poly_forward', **ycoeff_forward) xcoeff_index = lines.index('*xBackwardCoefficients 21 2') xcoeff_backward = coeffs_from_pcf(degree, lines[xcoeff_index + 1: xcoeff_index + 22]) x_poly_backward = models.Polynomial2D(degree, name='x_poly_backward', **xcoeff_backward) ycoeff_index = lines.index('*yBackwardCoefficients 21 2') ycoeff_backward = coeffs_from_pcf(degree, lines[ycoeff_index + 1: ycoeff_index + 22]) y_poly_backward = models.Polynomial2D(degree, name='y_poly_backward', **ycoeff_backward) x_poly_forward.inverse = x_poly_backward y_poly_forward.inverse = y_poly_backward poly_mapping1 = Mapping((0, 1, 0, 1)) poly_mapping1.inverse = Identity(2) poly_mapping2 = Identity(2) poly_mapping2.inverse = Mapping((0, 1, 0, 1)) model = input_rot_shift | rotation | scale | output_rot_shift | \ poly_mapping1 | x_poly_forward & y_poly_forward | poly_mapping2 f = AsdfFile() f.tree = {'model': model} f.write_to(outname)
def test_bounding_box_pass_with_ignored(): """Test the possiblity of setting ignored variables in bounding box""" model = models.Polynomial2D(2) bbox = ModelBoundingBox.validate(model, (-1, 1), ignored=['y']) model.bounding_box = bbox assert model.bounding_box.bounding_box() == (-1, 1) assert model.bounding_box == bbox model = models.Polynomial2D(2) bind_bounding_box(model, (-1, 1), ignored=['y']) assert model.bounding_box.bounding_box() == (-1, 1) assert model.bounding_box == bbox
def test_linear_fitter_with_weights(): """Regression test for #7035""" Xin, Yin = np.mgrid[0:21, 0:21] fitter = LinearLSQFitter() with NumpyRNGContext(_RANDOM_SEED): zsig = np.random.normal(0, 0.01, size=Xin.shape) p2 = models.Polynomial2D(3) p2.parameters = np.arange(10)/1.2 z = p2(Xin, Yin) pmod = fitter(models.Polynomial2D(3), Xin, Yin, z + zsig, weights=zsig**(-2)) assert_allclose(pmod.parameters, p2.parameters, atol=10 ** (-2))
def test_linear_fitter_with_weights_flat(): """Same as the above #7035 test but with flattened inputs""" Xin, Yin = np.mgrid[0:21, 0:21] Xin, Yin = Xin.flatten(), Yin.flatten() fitter = LinearLSQFitter() with NumpyRNGContext(_RANDOM_SEED): zsig = np.random.normal(0, 0.01, size=Xin.shape) p2 = models.Polynomial2D(3) p2.parameters = np.arange(10)/1.2 z = p2(Xin, Yin) pmod = fitter(models.Polynomial2D(3), Xin, Yin, z + zsig, weights=zsig**(-2)) assert_allclose(pmod.parameters, p2.parameters, atol=10 ** (-2))
def create_channel_selector(alpha, lam, channel, beta, ch_v2, ch_v3): if channel == 1: nslice = range(101, 122) #21 elif channel == 2: nslice = range(201, 218) #17 elif channel == 3: nslice = 16 elif channel == 4: nslice = 12 else: raise ValueError("Incorrect channel #") # transformation from local system (alpha, beta) to V2/V3 p_v2 = models.Polynomial2D(2) p_v3 = models.Polynomial2D(2) p_v2.c0_0, p_v2.c0_1, p_v2.c1_0, p_v2.c1_1 = ch_v2[1:] p_v3.c0_0, p_v3.c0_1, p_v3.c1_0, p_v3.c1_1 = ch_v3[1:] ab_v2v3 = p_v2 & p_v3 ind = [] for i in range(5): for j in range(5): ind.append((i, j)) selector = {} # In the paper the formula is (x-xs)^j*y^i, so the 'x' corresponds # to y in modeling. - swapped in Mapping axs = alpha.field('x_s') lxs = lam.field('x_s') #for i in range(nslice): for i, sl in enumerate(nslice): ashift = models.Shift(axs[i]) lshift = models.Shift(lxs[i]) palpha = models.Polynomial2D(8) plam = models.Polynomial2D(8) for index, coeff in zip(ind, alpha[i][1:]): setattr(palpha, 'c{0}_{1}'.format(index[0], index[1]), coeff) for index, coeff in zip(ind, lam[i][1:]): setattr(plam, 'c{0}_{1}'.format(index[0], index[1]), coeff) alpha_model = ashift & models.Identity(1) | palpha lam_model = lshift & models.Identity(1) | plam beta_model = models.Const1D(beta[0] + (i - 1) * beta[1]) # Note swapping of axes a_b_l = models.Mapping( (1, 0, 0, 1, 0)) | alpha_model & beta_model & lam_model v2_v3_l = a_b_l | models.Mapping( (0, 1, 0, 1, 2)) | ab_v2v3 & models.Identity(1) selector[sl] = v2_v3_l # return alpha, beta, lambda return selector
def fit_polynomial(data, degree, mask=None, sigma_clip_background=False): """ This function ... :param data: :param degree: :param mask: :param sigma_clip_background: :return: """ if sigma_clip_background: mask = statistics.sigma_clip_mask(data, sigma_level=3.0, mask=mask) # Fit the data using astropy.modeling poly_init = models.Polynomial2D(degree=degree) fit_model = fitting.LevMarLSQFitter() # Split x, y and z values that are not masked x_values, y_values, z_values = general.split_xyz(data, mask=mask, arrays=True) # Ignore model linearity warning from the fitter with warnings.catch_warnings(): warnings.simplefilter('ignore') poly = fit_model(poly_init, x_values, y_values, z_values) # What comes out is the model with the parameters set # Return the polynomial model and the new mask if sigma_clip_background: return poly, mask # Return the polynomial model else: return poly
def _calculate_dvel_2D(self): """ Fit a 2D surface to dvel vs. pixel vs. order """ # threshold (units of MAD) to throw out shifts sigclip = 5 vshift = self.vshift.copy() med = np.median(vshift) mad = np.median(np.abs(vshift - med)) bout = np.abs(vshift - med) > sigclip * mad vshift = ma.masked_array(vshift, bout) if np.std(vshift) > 25: print("WARNING: velocity shifts not well determined") vshift *= 0 pix = np.arange(self.npix) ord = np.arange(self.nord) x, y = np.meshgrid(self.pixmid-np.mean(pix), ord) p_init = models.Polynomial2D(degree=3) fit_p = fitting.LevMarLSQFitter() p = fit_p(p_init, x, y, vshift) dvel = np.zeros((self.nord, self.npix)) XX, YY = np.meshgrid(pix-np.mean(pix), ord) fit = p(XX, YY) dvel = dvel + fit return dvel
def image_poly_filter(image, mask=None, degree=2, return_bg=False): ''' polynominal filter the image ''' if degree is None: return image import warnings from astropy.modeling import models, fitting if mask is None: mask = np.ones(image.shape) mask[image == 0] = 0 sp = np.where(mask != 0) Nx, Ny = image.shape x, y = np.meshgrid(np.arange(Nx), np.arange(Ny)) p_init = models.Polynomial2D(degree=degree) fit_p = fitting.LevMarLSQFitter() with warnings.catch_warnings(): # Ignore model linearity warning from the fitter warnings.simplefilter('ignore') p = fit_p(p_init, x[sp], y[sp], image[sp]) bgmap = p(x, y) image_filt = image - bgmap if return_bg: return image_filt, bgmap return image_filt
def test_model_copy_with_bounding_box(): model = models.Polynomial2D(2) bbox = ModelBoundingBox.validate(model, ((-0.5, 1047.5), (-0.5, 2047.5)), order='F') # No bbox model_copy = model.copy() assert id(model_copy) != id(model) assert model_copy.get_bounding_box() == model.get_bounding_box() == None # with bbox model.bounding_box = bbox model_copy = model.copy() assert id(model_copy) != id(model) assert id(model_copy.bounding_box) != id(model.bounding_box) for index, interval in model.bounding_box.intervals.items(): interval_copy = model_copy.bounding_box.intervals[index] assert interval == interval_copy assert id(interval) != interval_copy # add model to compound model model1 = model | models.Identity(1) model_copy = model1.copy() assert id(model_copy) != id(model1) assert model_copy.get_bounding_box() == model1.get_bounding_box() == None
def create_xy_models(data, channel, coeff_names, name): """ Create a 2D polynomial model for the transformation local_MIRI --> detector frame. """ nslices = len(data) sl = channel * 100 + np.arange(1, nslices + 1) shname = "shift_{0}".format(name) pname = "polynomial_{0}".format(name) transforms = {} for i in range(nslices): sl = channel * 100 + i + 1 al = data[i] xs = al[0] coeffs = {} for c, val in zip(coeff_names, al[1:]): coeffs[c] = val # First we do Adrian's transforms thisxform = models.Shift( -xs, name=shname) & models.Identity(1) | models.Polynomial2D( 8, name=pname, **coeffs) # Then we need to shift from the 1-indexed pixels used by transforms to the # 0-indexed pixels used by the pipeline # (both Adrian and the pipeline include reference pixels) # Only a single output so only a single shift thisshift = models.Shift(-1) # Put the models together transforms[sl] = thisxform | thisshift return transforms
def create_poly_models(data, channel, coeff_names, name): """ Create a 2D polynomial model for the transformation detector --> local MIRI frame Works for alpha and lambda coordinates. """ nslices = len(data) sl = channel * 100 + np.arange(1, nslices + 1) transforms = {} for i in range(nslices): sl = channel * 100 + i + 1 al = data[i] xs = al[0] coeffs = {} for c, val in zip(coeff_names, al[1:]): coeffs[c] = val # First we need to shift from the 0-indexed pixels input by the pipeline to the # 1-indexed pixels used by Adrians transforms # (both Adrian and the pipeline include reference pixels) # Remember that the coordinates here are in order y,x thisshift = models.Shift(1) & models.Shift(1) # Now do Adrians transforms thisxform = models.Identity(1) & models.Shift( -xs) | models.Polynomial2D(8, name=name, **coeffs) # Put the models together transforms[sl] = thisshift | thisxform return transforms
def quadratic_peakfinder(x, y, z): """ Fit for the peak ``(x, y)`` position by fitting the data with a 2nd-degree 2D polynomial. Parameters ---------- x : array-like Input coordinates. y : array-like Input coordinates. z : array-like Input values. Returns ------- x, y : float The ``x`` and ``y`` position of the fitted peak value. """ p_init = models.Polynomial2D(degree=2) # default coefficients are zero fitter = fitting.LinearLSQFitter() p_fit = fitter(p_init, x, y, z) y_peak = ((2 * p_fit.c2_0 * p_fit.c0_1 - p_fit.c1_0 * p_fit.c1_1) / (p_fit.c1_1**2 - 4 * p_fit.c0_2 * p_fit.c2_0)) x_peak = -(p_fit.c0_1 + 2 * p_fit.c0_2 * y_peak) / p_fit.c1_1 return x_peak, y_peak
def to_model(coeffs, degree=5): """ Creates an astropy.modeling.Model object Parameters ---------- coeffs : array like Coefficients in the same order as in the ISIM transformations file. degree : int Degree of polynomial. Default is 5 as in the ISIM file but many of the polynomials are of a smaller degree. Returns ------- poly : astropy.modeling.Polynomial2D Polynomial model transforming one coordinate (x or y) between two systems. """ c = {} names = [] for i in range(5): for j in range(5): if i+j < degree+1: names.append('c{0}_{1}'.format(i, j)) for name, coe in zip(names, coeffs): c[name] = coe return models.Polynomial2D(degree, **c)
def gauss_center(data, sigma=3., theta=0.): """center the data by fitting a 2d gaussian to the region. Parameters ---------- data: float should be a 2d array, the initial center is used to estimate the fit center """ # use a smaller bounding box so that we are only fitting the local data delta = int(len(data) / 2) # guess the center amp = data.max() - data.min() # guess the amplitude ldata = len(data) yy, xx = np.mgrid[:ldata, :ldata] # Fit model to data fit = fitting.LevMarLSQFitter() # Gaussian2D(amp,xmean,ymean,xstd,ystd,theta) + a constant model = (models.Gaussian2D(amp, delta, delta, sigma, sigma, theta) + models.Polynomial2D(c0_0=data.min(), degree=0)) with warnings.catch_warnings(): # Ignore model linearity warning from the fitter warnings.simplefilter('ignore') results = fit(model, xx, yy, data) # previous yield amp, ycenter, xcenter, sigma, offset return results
def test_model_copy_with_compound_bounding_box(): model = models.Polynomial2D(2) bbox = {(0,): (-0.5, 1047.5), (1,): (-0.5, 3047.5)} cbbox = CompoundBoundingBox.validate(model, bbox, selector_args=[('x', True)], order='F') # No cbbox model_copy = model.copy() assert id(model_copy) != id(model) assert model_copy.get_bounding_box() == model.get_bounding_box() == None # with cbbox model.bounding_box = cbbox model_copy = model.copy() assert id(model_copy) != id(model) assert id(model_copy.bounding_box) != id(model.bounding_box) assert model_copy.bounding_box.selector_args == model.bounding_box.selector_args assert id(model_copy.bounding_box.selector_args) != id(model.bounding_box.selector_args) for selector, bbox in model.bounding_box.bounding_boxes.items(): for index, interval in bbox.intervals.items(): interval_copy = model_copy.bounding_box.bounding_boxes[selector].intervals[index] assert interval == interval_copy assert id(interval) != interval_copy # add model to compound model model1 = model | models.Identity(1) model_copy = model1.copy() assert id(model_copy) != id(model1) assert model_copy.get_bounding_box() == model1.get_bounding_box() == None
def test_2d_with_weights_without_sigma_clip(self): model = models.Polynomial2D(0) fitter = LevMarLSQFitter() # LinearLSQFitter doesn't handle weights properly in 2D with pytest.warns(AstropyUserWarning, match=r'Model is linear in parameters'): fit = fitter(model, self.x, self.y, self.z, weights=self.weights) assert(fit.parameters[0] > 1.0) # outliers pulled it high
def setup_class(self): self.model = models.Polynomial2D(2) self.y, self.x = np.mgrid[:5, :5] def poly2(x, y): return 1 + 2 * x + 3 * x ** 2 + 4 * y + 5 * y ** 2 + 6 * x * y self.z = poly2(self.x, self.y)
def fit_airy_2d(data, x=None, y=None): """Fit an AiryDisk2D model to the data.""" delta = int(len(data) / 2) # guess the center ldata = len(data) if not x: x = delta if not y: y = delta fixed_pars = {"x_0": True, "y_0": True} # hold these constant yy, xx = np.mgrid[:ldata, :ldata] # fit model to the data fit = fitting.LevMarLSQFitter() # AiryDisk2D(amplitude, x_0, y_0, radius) + constant model = (models.AiryDisk2D( np.max(data), x_0=x, y_0=y, radius=delta, fixed=fixed_pars) + models.Polynomial2D(c0_0=data.min(), degree=0)) with warnings.catch_warnings(): # Ignore model warnings for new_plot_window warnings.simplefilter('ignore') results = fit(model, xx, yy, data) return results
def fit_poly_surface_2D(x_norm, y_norm, z, weights=None, polytype='chebyshev', poly_deg=5, timit=False, debug_level=0): """ Calculate 2D polynomial fit to normalized x and y values. Wrapper function for using the astropy fitting library. INPUT: 'x_norm' : x-values (pixels) of all the lines, re-normalized to [-1,+1] 'm_norm' : order numbers of all the lines, re-normalized to [-1,+1] 'z' : the 2-dim array of 'observed' values 'weights' : weights to use in the fitting 'polytype' : types of polynomials to use (either '(p)olynomial' (default), '(l)egendre', or '(c)hebyshev' are accepted) 'poly_deg' : degree of the polynomials 'timit' : boolean - do you want to measure execution run time? 'debug_level' : for debugging... OUTPUT: 'p' : coefficients of the best-fit polynomials """ if timit: start_time = time.time() if polytype.lower() in ['p', 'polynomial']: p_init = models.Polynomial2D(poly_deg) if debug_level > 0: print('OK, using standard polynomials...') elif polytype.lower() in ['c', 'chebyshev']: p_init = models.Chebyshev2D(poly_deg, poly_deg) if debug_level > 0: print('OK, using Chebyshev polynomials...') elif polytype.lower() in ['l', 'legendre']: p_init = models.Legendre2D(poly_deg, poly_deg) if debug_level > 0: print('OK, using Legendre polynomials...') else: print( "ERROR: polytype not recognised ['(P)olynomial' / '(C)hebyshev' / '(L)egendre']" ) return fit_p = fitting.LevMarLSQFitter() with warnings.catch_warnings(): # Ignore model linearity warning from the fitter warnings.simplefilter('ignore') p = fit_p(p_init, x_norm, y_norm, z, weights=weights) if timit: print('Time elapsed: ' + np.round(time.time() - start_time, 2).astype(str) + ' seconds...') return p
def fit_gaussian_to_cutout(cutout, seeing_pix): """Fit a 2D gaussian to the cutout to determine the location of the maximum Inputs: cutout: a small array representing a cutout from the direct image. seeing_pix: a guess of the seeing size in pixel for gaussian fit Output: res: result of the 2D polynomial (res[0]) and gaussian fit (res[1]). The location of the source is determined by the gaussian part, of course. (MMB: Are these backwards? e.g. gaussian is res[0]?) """ g_init = models.Gaussian2D(amplitude = np.max(cutout), \ x_mean = np.shape(cutout)[1]/2,y_mean = np.shape(cutout)[0]/2,\ x_stddev = seeing_pix, y_stddev = seeing_pix) #allow for some DC offset const_init = models.Polynomial2D(2) #Use LevMar LSQ fitter fitter = fitting.LevMarLSQFitter() #Just get x,y grid for the cutout y, x = np.mgrid[:np.shape(cutout)[0], :np.shape(cutout)[1]] #fit res = fitter(g_init + const_init, x, y, cutout) #We want x,y location from the Gaussian part #print(res[0].amplitude.value, res[0].x_stddev.value) return res
def to_model(coeffs, degree=5): """ Creates an astropy.modeling.Model object Parameters ---------- coeffs : array like Coefficients from the ISIM transformations file. degree : int Degree of polynomial. Default is 5 as in the ISIM file but many of the polynomials are of a smaller degree. Returns ------- poly : astropy.modeling.Polynomial2D Polynomial model transforming one coordinate (x or y) between two systems. """ #map Colin's coefficients into the order expected by Polynomial2D c = {} for cname in coeffs.colnames: siaf_i = int(cname[-2]) siaf_j = int(cname[-1]) name = 'c{0}_{1}'.format(siaf_i - siaf_j, siaf_j) c[name] = coeffs[cname].data[0] #0,0 coefficient should not be used, according to Colin's TR #JWST-STScI-001550 c['c0_0'] = 0 return models.Polynomial2D(degree, **c)
def create_xy_models(data, channel, coeff_names, name): """ Create a 2D polynomial model for the transformation local_MIRI --> detector frame. """ nslices = len(data) sl = channel * 100 + np.arange(1, nslices + 1) shname = "shift_{0}".format(name) pname = "polynomial_{0}".format(name) transforms = {} for i in range(nslices): sl = channel * 100 + i + 1 al = data[i] xs = al[0] coeffs = {} for c, val in zip(coeff_names, al[1:]): coeffs[c] = val # As of CDP-8b both the IDT transform as the pipeline use 0-indexed pixels, and # include the 4 reference pixels in their counting. Therefore we do not need to # apply any index shift, just the transform. thisxform = models.Shift( -xs, name=shname) & models.Identity(1) | models.Polynomial2D( 8, name=pname, **coeffs) transforms[sl] = thisxform return transforms
def create_poly_models(data, channel, coeff_names, name): """ Create a 2D polynomial model for the transformation detector --> local MIRI frame Works for alpha and lambda coordinates. """ nslices = len(data) sl = channel * 100 + np.arange(1, nslices + 1) transforms = {} for i in range(nslices): sl = channel * 100 + i + 1 al = data[i] xs = al[0] coeffs = {} for c, val in zip(coeff_names, al[1:]): coeffs[c] = val # As of CDP-8b both the IDT transform as the pipeline use 0-indexed pixels, and # include the 4 reference pixels in their counting. Therefore we do not need to # apply any index shift, just the transform. thisxform = models.Identity(1) & models.Shift( -xs) | models.Polynomial2D(8, name=name, **coeffs) # Put the models together transforms[sl] = thisxform return transforms
def test_2d_without_weights_with_sigma_clip(self): model = models.Polynomial2D(0) fitter = FittingWithOutlierRemoval(LinearLSQFitter(), sigma_clip, niter=3, sigma=3.) fit, mask = fitter(model, self.x, self.y, self.z) assert((~mask).sum() == self.z.size - 2) assert(mask[0, 0] and mask[0, 1]) assert_allclose(fit.parameters[0], 0.0, atol=10**(-2))
def test_p2_nset_npset(self): """N param_sets, N 2D data sets, Poly2d""" p2 = models.Polynomial2D(5, n_models=2) xx = np.array([self.x, self.x]) yy = np.array([self.y, self.y]) z = p2(xx, yy) assert z.shape == (2, 10, 10)
def test_2d_with_weights_with_sigma_clip(self): """smoke test for #7020 - fails without fitting.py patch because weights does not propagate""" model = models.Polynomial2D(0) fitter = FittingWithOutlierRemoval(LevMarLSQFitter(), sigma_clip, niter=3, sigma=3.) fit, filtered = fitter(model, self.x, self.y, self.z, weights=self.weights) assert(fit.parameters[0] > 10**(-2)) # weights pulled it > 0 assert(fit.parameters[0] < 1.0) # outliers didn't pull it out of [-1:1] because they had been removed
def test_2d_with_weights_without_sigma_clip(self, fitter): fitter = fitter() model = models.Polynomial2D(0) with pytest.warns(AstropyUserWarning, match=r'Model is linear in parameters'): fit = fitter(model, self.x, self.y, self.z, weights=self.weights) assert(fit.parameters[0] > 1.0) # outliers pulled it high
def posTrans(self, posMchs, stars): #print(posMchs) for i, tm in enumerate(posMchs): if i==0: dataOi = posMchs[i][0] dataTi = posMchs[i][1] else: dataOi = np.concatenate([dataOi,posMchs[i][0]]) dataTi = np.concatenate([dataTi,posMchs[i][1]]) xshift,yshift, xrms, yrms = self.evaluatePos(dataOi, dataTi) print("xshift=%.2f, yshift=%.2f, xrms=%.5f, yrms=%.5f"%(xshift,yshift, xrms, yrms)) ''' minLen = dataTi.shape[0] if minLen>dataOi.shape[0]: minLen=dataOi.shape[0] dataTi2 = dataTi[:minLen] dataOi2 = dataOi[:minLen] ''' dataTi2 = dataTi dataOi2 = dataOi oix = dataOi2[:,0] oiy = dataOi2[:,1] tix = dataTi2[:,0] tiy = dataTi2[:,1] p_init = models.Polynomial2D(degree=1) fit_p = fitting.LevMarLSQFitter() with warnings.catch_warnings(): # Ignore model linearity warning from the fitter warnings.simplefilter('ignore') tixp = fit_p(p_init, oix, oiy, tix) tiyp = fit_p(p_init, oix, oiy, tiy) tix2 = tixp(oix, oiy) tiy2 = tiyp(oix, oiy) dataTi2 = np.concatenate([tix2.reshape((tix2.shape[0],1)),tiy2.reshape((tix2.shape[0],1))],axis=1) xshift,yshift, xrms, yrms = self.evaluatePos(dataTi, dataTi2) print("xshift=%.2f, yshift=%.2f, xrms=%.5f, yrms=%.5f"%(xshift,yshift, xrms, yrms)) starPoss = stars[:,3:5] oix = starPoss[:,0] oiy = starPoss[:,1] tix2 = tixp(oix, oiy) tiy2 = tiyp(oix, oiy) starPossTi = np.concatenate([tix2.reshape((tix2.shape[0],1)),tiy2.reshape((tix2.shape[0],1))],axis=1) xshift,yshift, xrms, yrms = self.evaluatePos(starPoss, starPossTi) stars[:,3:5] = starPossTi print("xshift=%.2f, yshift=%.2f, xrms=%.5f, yrms=%.5f"%(xshift,yshift, xrms, yrms)) return stars