def return_synthetic_sdss_gri_img(filename,
				lupton_alpha=0.5, lupton_Q=0.5, scale_min=1e-4,
                                b_fac=0.7, g_fac=1.0, r_fac=1.3,
				seed_boost=1.0,
			 	r_petro_kpc=None,
				**kwargs):

    fail_flag=True		# looks for "bad" backgrounds, and tells us to try again
    n_iter = 1
    while(fail_flag and (n_iter < 2)):
        fail_flag=False
	try:
            seed=int(filename[filename.index('broadband_')+10:filename.index('.fits')])*(n_iter)*seed_boost
        except:
	    try:
                seed=int(filename[filename.index('.fits')-3:filename.index('.fits')])*(n_iter)*seed_boost
	    except:
		seed=1234

        n_iter+=1


        b_image, rp, the_used_seed,this_fail_flag    = sunpy__synthetic_image.build_synthetic_image(filename, 'g_SDSS.res',
				seed=seed,
				r_petro_kpc=r_petro_kpc,
				fix_seed=False,
				**kwargs)
        if(this_fail_flag):
	  fail_flag=True

        g_image, dummy, the_used_seed,this_fail_flag = sunpy__synthetic_image.build_synthetic_image(filename, 'r_SDSS.res',
				seed=the_used_seed,
				r_petro_kpc=rp,
				fix_seed=True,
				**kwargs)
        if(this_fail_flag):
          fail_flag=True

        r_image, dummy, the_used_seed, this_fail_flag = sunpy__synthetic_image.build_synthetic_image(filename, 'i_SDSS.res',
                                seed=the_used_seed,
				r_petro_kpc=rp,
				fix_seed=True,
				**kwargs)
        if(this_fail_flag):
            fail_flag=True

    n_pixels = r_image.shape[0]
    img = np.zeros((n_pixels, n_pixels, 3), dtype=float)

    b_image *= b_fac
    g_image *= g_fac
    r_image *= r_fac

    I = (r_image + g_image + b_image)/3
    val = np.arcsinh( lupton_alpha * lupton_Q * (I - scale_min))/lupton_Q
    I[ I < 1e-6 ] = 1e100		# from below, this effectively sets the pixel to 0

    img[:,:,0] = r_image * val / I
    img[:,:,1] = g_image * val / I
    img[:,:,2] = b_image * val / I

    maxrgbval = np.amax(img, axis=2)

    changeind = maxrgbval > 1.0
    img[changeind,0] = img[changeind,0]/maxrgbval[changeind]
    img[changeind,1] = img[changeind,1]/maxrgbval[changeind]
    img[changeind,2] = img[changeind,2]/maxrgbval[changeind]

    minrgbval = np.amin(img, axis=2)
    changeind = minrgbval < 0.0
    img[changeind,0] = 0
    img[changeind,1] = 0
    img[changeind,2] = 0

    changind = I < 0
    img[changind,0] = 0
    img[changind,1] = 0
    img[changind,2] = 0
    img[img<0] = 0


    del b_image, g_image, r_image, I, val
    gc.collect()

    img[img<0] = 0
    return rp, img
Exemple #2
0
def return_synthetic_jwst_img(filename,
                              lupton_alpha=0.5,
                              lupton_Q=0.5,
                              scale_min=1e-4,
                              b_fac=1.0,
                              g_fac=1.0,
                              r_fac=1.0,
                              max=1.0,
                              dynrng=1e3,
                              r_petro_kpc=None,
                              **kwargs):

    fail_flag = True  # looks for "bad" backgrounds, and tells us to try again
    n_iter = 1
    while (fail_flag and (n_iter < 2)):
        fail_flag = False
        try:
            seed = int(filename[filename.index('broadband_') +
                                10:filename.index('.fits')])
        except:
            try:
                seed = int(filename[filename.index('broadband_red_') +
                                    14:filename.index('.fits')])
            except:
                seed = int(filename[filename.index('broadband_rest_') +
                                    15:filename.index('.fits')])

        n_iter += 1

    b_image, rp, the_used_seed, this_fail_flag, _, _ = sunpy__synthetic_image.build_synthetic_image(
        filename,
        'NIRCAM_prelimfiltersonly_F277W',  # 25,
        seed=seed,
        fix_seed=False,
        r_petro_kpc=r_petro_kpc,
        **kwargs)
    if (this_fail_flag):
        fail_flag = True

    dummy, dummy, the_used_seed, this_fail_flag, _, _ = sunpy__synthetic_image.build_synthetic_image(
        filename,
        'NIRCAM_prelimfiltersonly_F277W',
        seed=the_used_seed,
        fix_seed=True,
        r_petro_kpc=rp,
        **kwargs)
    if (this_fail_flag):
        fail_flag = True

    g_image, dummy, the_used_seed, this_fail_flag, _, _ = sunpy__synthetic_image.build_synthetic_image(
        filename,
        'NIRCAM_prelimfiltersonly_F356W',
        seed=the_used_seed,
        fix_seed=True,
        r_petro_kpc=rp,
        **kwargs)
    if (this_fail_flag):
        fail_flag = True

    r_image, dummy, the_used_seed, this_fail_flag, _, _ = sunpy__synthetic_image.build_synthetic_image(
        filename,
        'NIRCAM_prelimfiltersonly_F444W',
        seed=the_used_seed,
        fix_seed=True,
        r_petro_kpc=rp,
        **kwargs)
    if (this_fail_flag):
        fail_flag = True

    n_pixels = r_image.shape[0]
    img = np.zeros((n_pixels, n_pixels, 3), dtype=float)

    b_image *= b_fac
    g_image *= g_fac
    r_image *= r_fac

    I = (r_image + g_image + b_image) / 3
    val = np.arcsinh(lupton_alpha * lupton_Q * (I - scale_min)) / lupton_Q
    I[I < 1e-6] = 1e100  # from below, this effectively sets the pixel to 0

    img[:, :, 0] = r_image * val / I
    img[:, :, 1] = g_image * val / I
    img[:, :, 2] = b_image * val / I

    maxrgbval = np.amax(img, axis=2)

    changeind = maxrgbval > 1.0
    img[changeind, 0] = img[changeind, 0] / maxrgbval[changeind]
    img[changeind, 1] = img[changeind, 1] / maxrgbval[changeind]
    img[changeind, 2] = img[changeind, 2] / maxrgbval[changeind]

    minrgbval = np.amin(img, axis=2)
    changeind = minrgbval < 0.0
    img[changeind, 0] = 0
    img[changeind, 1] = 0
    img[changeind, 2] = 0

    changind = I < 0
    img[changind, 0] = 0
    img[changind, 1] = 0
    img[changind, 2] = 0
    img[img < 0] = 0

    del b_image, g_image, r_image, I, val
    gc.collect()

    img[img < 0] = 0
    return rp, img
def return_synthetic_hst_img(filename,
                                lupton_alpha=0.5, lupton_Q=0.5, scale_min=1e-4,
                                b_fac=1.0, g_fac=1.0, r_fac=1.0, max=1.0, dynrng=1e3,
                                **kwargs):

    try:
       seed=int(filename[filename.index('broadband_')+10:filename.index('.fits')])
    except:
       try:
          seed=int(filename[filename.index('broadband_red_')+14:filename.index('.fits')])
       except:
          seed=int(filename[filename.index('broadband_rest_')+15:filename.index('.fits')])


    b_image, rp, dummy, dummy    = sunpy__synthetic_image.build_synthetic_image(filename, 22,		#25,
                                seed=seed, fix_seed=True,
                                #r_petro_kpc=None,
                                **kwargs)
    dummy, dummy, dummy, dummy  = sunpy__synthetic_image.build_synthetic_image(filename, 25,
                                seed=seed, fix_seed=True,
                                #r_petro_kpc=rp,
                                **kwargs)

    g_image, dummy, dummy, dummy = sunpy__synthetic_image.build_synthetic_image(filename, 26,
                                seed=seed, fix_seed=True,
                                #r_petro_kpc=rp,
                                **kwargs)
    r_image, dummy, dummy, dummy = sunpy__synthetic_image.build_synthetic_image(filename, 27,
                                seed=seed, fix_seed=True,
                                #r_petro_kpc=rp,
                                **kwargs)

    n_pixels = r_image.shape[0]
    img = np.zeros((n_pixels, n_pixels, 3), dtype=float)

    b_image *= b_fac
    g_image *= g_fac
    r_image *= r_fac

    if 0:
       I = (r_image + g_image + b_image)/3
       val = np.arcsinh( lupton_alpha * lupton_Q * (I - scale_min))/lupton_Q
       I[ I < 1e-8 ] = 1e20               # from below, this effectively sets the pixel to 0

       img[:,:,0] = r_image * val / I
       img[:,:,1] = g_image * val / I
       img[:,:,2] = b_image * val / I

       maxrgbval = np.amax(img, axis=2)

       changeind = maxrgbval > 1.0
       img[changeind,0] = img[changeind,0]/maxrgbval[changeind]
       img[changeind,1] = img[changeind,1]/maxrgbval[changeind]
       img[changeind,2] = img[changeind,2]/maxrgbval[changeind]

       minrgbval = np.amin(img, axis=2)
       changeind = minrgbval < 0.0
       img[changeind,0] = 0
       img[changeind,1] = 0
       img[changeind,2] = 0

       changind = I < 0
       img[changind,0] = 0
       img[changind,1] = 0
       img[changind,2] = 0
       img[img<0] = 0

    else:
        img[:,:,0] = np.log10(r_image )  # / max=1.0, dynrng=1e3,
	img[:,:,1] = np.log10(g_image )
	img[:,:,2] = np.log10(b_image )

        img -= np.log10( max/dynrng )
        img /= np.log10( dynrng )

        img[img>1] = 1
	I = img
	val = img

    img[img<0] = 0
    print "img min/max/mean "+str(img.min())+"  "+str(img.max())+"  "+str(img.mean())
    print " "

    del b_image, g_image, r_image, I, val
    gc.collect()

    img[img<0] = 0
    return rp, img
Exemple #4
0
def return_synthetic_sdss_gri_img(filename,
                                  lupton_alpha=0.5,
                                  lupton_Q=0.5,
                                  scale_min=1e-4,
                                  b_fac=0.7,
                                  g_fac=1.0,
                                  r_fac=1.3,
                                  seed_boost=1.0,
                                  r_petro_kpc=None,
                                  **kwargs):

    fail_flag = True  # looks for "bad" backgrounds, and tells us to try again
    n_iter = 1
    while (fail_flag and (n_iter < 2)):
        fail_flag = False
        try:
            seed = int(
                filename[filename.index('broadband_') +
                         10:filename.index('.fits')]) * (n_iter) * seed_boost
        except:
            try:
                seed = int(filename[filename.index('.fits') - 3:filename.
                                    index('.fits')]) * (n_iter) * seed_boost
            except:
                seed = 1234

        n_iter += 1

        # The calls to build_synthetic_image had to be updated to account for changes in the number
        # of return values (previously 4, now 6).  We don't need the other 2 values here, but we
        # have to catch them so the code won't complain about too many return values to unpack.
        b_image, rp, the_used_seed, this_fail_flag, _, _ = \
            sunpy__synthetic_image.build_synthetic_image(filename, 'g_SDSS.res',
                                                         seed=seed,
                                                         r_petro_kpc=r_petro_kpc,
                                                         fix_seed=False,
                                                         **kwargs)
        if (this_fail_flag):
            fail_flag = True

        g_image, dummy, the_used_seed, this_fail_flag, _, _ = \
            sunpy__synthetic_image.build_synthetic_image(filename, 'r_SDSS.res',
                                                         seed=the_used_seed,
                                                         r_petro_kpc=rp,
                                                         fix_seed=True,
                                                         **kwargs)
        if (this_fail_flag):
            fail_flag = True

        r_image, dummy, the_used_seed, this_fail_flag, _, _ = \
            sunpy__synthetic_image.build_synthetic_image(filename, 'i_SDSS.res',
                                                         seed=the_used_seed,
                                                         r_petro_kpc=rp,
                                                         fix_seed=True,
                                                         **kwargs)
        if (this_fail_flag):
            fail_flag = True

    n_pixels = r_image.shape[0]
    img = np.zeros((n_pixels, n_pixels, 3), dtype=float)

    b_image *= b_fac
    g_image *= g_fac
    r_image *= r_fac

    I = (r_image + g_image + b_image) / 3
    val = np.arcsinh(lupton_alpha * lupton_Q * (I - scale_min)) / lupton_Q
    I[I < 1e-6] = 1e100  # from below, this effectively sets the pixel to 0

    img[:, :, 0] = r_image * val / I
    img[:, :, 1] = g_image * val / I
    img[:, :, 2] = b_image * val / I

    maxrgbval = np.amax(img, axis=2)

    changeind = maxrgbval > 1.0
    img[changeind, 0] = img[changeind, 0] / maxrgbval[changeind]
    img[changeind, 1] = img[changeind, 1] / maxrgbval[changeind]
    img[changeind, 2] = img[changeind, 2] / maxrgbval[changeind]

    minrgbval = np.amin(img, axis=2)
    changeind = minrgbval < 0.0
    img[changeind, 0] = 0
    img[changeind, 1] = 0
    img[changeind, 2] = 0

    changind = I < 0
    img[changind, 0] = 0
    img[changind, 1] = 0
    img[changind, 2] = 0
    img[img < 0] = 0

    del b_image, g_image, r_image, I, val
    gc.collect()

    img[img < 0] = 0
    return rp, img
Exemple #5
0
def return_synthetic_sdss_gri_img(filename,
                                  lupton_alpha=0.5,
                                  lupton_Q=0.5,
                                  scale_min=1e-4,
                                  b_fac=0.7,
                                  g_fac=1.0,
                                  r_fac=1.3,
                                  **kwargs):

    seed = int(filename[filename.index('broadband_') +
                        10:filename.index('.fits')])
    b_image, rp = sunpy__synthetic_image.build_synthetic_image(
        filename, 'g_SDSS.res', seed=seed, r_petro_kpc=None, **kwargs)
    g_image, dummy = sunpy__synthetic_image.build_synthetic_image(
        filename, 'r_SDSS.res', seed=seed, r_petro_kpc=rp, **kwargs)
    r_image, dummy = sunpy__synthetic_image.build_synthetic_image(
        filename, 'i_SDSS.res', seed=seed, r_petro_kpc=rp, **kwargs)

    n_pixels = r_image.shape[0]
    img = np.zeros((n_pixels, n_pixels, 3), dtype=float)

    b_image *= b_fac
    g_image *= g_fac
    r_image *= r_fac

    I = (r_image + g_image + b_image) / 3
    val = np.arcsinh(lupton_alpha * lupton_Q * (I - scale_min)) / lupton_Q
    I[I < 1e-6] = 1e100  # from below, this effectively sets the pixel to 0

    img[:, :, 0] = r_image * val / I
    img[:, :, 1] = g_image * val / I
    img[:, :, 2] = b_image * val / I

    maxrgbval = np.amax(img, axis=2)

    changeind = maxrgbval > 1.0
    img[changeind, 0] = img[changeind, 0] / maxrgbval[changeind]
    img[changeind, 1] = img[changeind, 1] / maxrgbval[changeind]
    img[changeind, 2] = img[changeind, 2] / maxrgbval[changeind]

    minrgbval = np.amin(img, axis=2)
    changeind = minrgbval < 0.0
    img[changeind, 0] = 0
    img[changeind, 1] = 0
    img[changeind, 2] = 0

    changind = I < 0
    img[changind, 0] = 0
    img[changind, 1] = 0
    img[changind, 2] = 0
    img[img < 0] = 0

    print "img min/max/mean " + str(img.min()) + "  " + str(
        img.max()) + "  " + str(img.mean())
    print " "

    del b_image, g_image, r_image, I, val
    gc.collect()

    img[img < 0] = 0
    return rp, img
Exemple #6
0
def return_synthetic_sdss_gri_img(filename, 
				lupton_alpha=0.5, lupton_Q=0.5, scale_min=1e-4, 
                                b_fac=0.7, g_fac=1.0, r_fac=1.3,
				seed_boost=1.0,
			 	r_petro_kpc=None,
				**kwargs):

    fail_flag=True		# looks for "bad" backgrounds, and tells us to try again
    n_iter = 1
    while(fail_flag and (n_iter < 2)):
        fail_flag=False
        seed=int(filename[filename.index('broadband_')+10:filename.index('.fits')])*(n_iter)*seed_boost
        n_iter+=1


        b_image, rp, the_used_seed,this_fail_flag    = sunpy__synthetic_image.build_synthetic_image(filename, 'g_SDSS.res', 
				seed=seed,
				r_petro_kpc=r_petro_kpc, 
				fix_seed=False,
				**kwargs)
        if(this_fail_flag):
	  fail_flag=True

        g_image, dummy, the_used_seed,this_fail_flag = sunpy__synthetic_image.build_synthetic_image(filename, 'r_SDSS.res', 
				seed=the_used_seed,
				r_petro_kpc=rp,
				fix_seed=True, 
				**kwargs)
        if(this_fail_flag):
          fail_flag=True

        r_image, dummy, the_used_seed, this_fail_flag = sunpy__synthetic_image.build_synthetic_image(filename, 'i_SDSS.res', 
                                seed=the_used_seed,
				r_petro_kpc=rp,
				fix_seed=True, 
				**kwargs)
        if(this_fail_flag):
            fail_flag=True

    n_pixels = r_image.shape[0]
    img = np.zeros((n_pixels, n_pixels, 3), dtype=float)
 
    b_image *= b_fac
    g_image *= g_fac
    r_image *= r_fac
 
    I = (r_image + g_image + b_image)/3
    val = np.arcsinh( lupton_alpha * lupton_Q * (I - scale_min))/lupton_Q
    I[ I < 1e-6 ] = 1e100		# from below, this effectively sets the pixel to 0

    img[:,:,0] = r_image * val / I
    img[:,:,1] = g_image * val / I
    img[:,:,2] = b_image * val / I

    maxrgbval = np.amax(img, axis=2)
 
    changeind = maxrgbval > 1.0
    img[changeind,0] = img[changeind,0]/maxrgbval[changeind]
    img[changeind,1] = img[changeind,1]/maxrgbval[changeind]
    img[changeind,2] = img[changeind,2]/maxrgbval[changeind]

    minrgbval = np.amin(img, axis=2)
    changeind = minrgbval < 0.0
    img[changeind,0] = 0
    img[changeind,1] = 0
    img[changeind,2] = 0

    changind = I < 0
    img[changind,0] = 0
    img[changind,1] = 0
    img[changind,2] = 0
    img[img<0] = 0


    del b_image, g_image, r_image, I, val
    gc.collect()

    img[img<0] = 0
    return rp, img
Exemple #7
0
def return_synthetic_hst_img(filename,
                             lupton_alpha=0.5,
                             lupton_Q=0.5,
                             scale_min=1e-4,
                             b_fac=1.0,
                             g_fac=1.0,
                             r_fac=1.0,
                             max=1.0,
                             dynrng=1e3,
                             **kwargs):

    try:
        seed = int(filename[filename.index('broadband_') +
                            10:filename.index('.fits')])
    except:
        try:
            seed = int(filename[filename.index('broadband_red_') +
                                14:filename.index('.fits')])
        except:
            seed = int(filename[filename.index('broadband_rest_') +
                                15:filename.index('.fits')])

    b_image, rp, dummy, dummy = sunpy__synthetic_image.build_synthetic_image(
        filename,
        22,  #25,
        seed=seed,
        fix_seed=True,
        #r_petro_kpc=None,
        **kwargs)
    dummy, dummy, dummy, dummy = sunpy__synthetic_image.build_synthetic_image(
        filename,
        25,
        seed=seed,
        fix_seed=True,
        #r_petro_kpc=rp,
        **kwargs)

    g_image, dummy, dummy, dummy = sunpy__synthetic_image.build_synthetic_image(
        filename,
        26,
        seed=seed,
        fix_seed=True,
        #r_petro_kpc=rp,
        **kwargs)
    r_image, dummy, dummy, dummy = sunpy__synthetic_image.build_synthetic_image(
        filename,
        27,
        seed=seed,
        fix_seed=True,
        #r_petro_kpc=rp,
        **kwargs)

    n_pixels = r_image.shape[0]
    img = np.zeros((n_pixels, n_pixels, 3), dtype=float)

    b_image *= b_fac
    g_image *= g_fac
    r_image *= r_fac

    if 0:
        I = (r_image + g_image + b_image) / 3
        val = np.arcsinh(lupton_alpha * lupton_Q * (I - scale_min)) / lupton_Q
        I[I < 1e-8] = 1e20  # from below, this effectively sets the pixel to 0

        img[:, :, 0] = r_image * val / I
        img[:, :, 1] = g_image * val / I
        img[:, :, 2] = b_image * val / I

        maxrgbval = np.amax(img, axis=2)

        changeind = maxrgbval > 1.0
        img[changeind, 0] = img[changeind, 0] / maxrgbval[changeind]
        img[changeind, 1] = img[changeind, 1] / maxrgbval[changeind]
        img[changeind, 2] = img[changeind, 2] / maxrgbval[changeind]

        minrgbval = np.amin(img, axis=2)
        changeind = minrgbval < 0.0
        img[changeind, 0] = 0
        img[changeind, 1] = 0
        img[changeind, 2] = 0

        changind = I < 0
        img[changind, 0] = 0
        img[changind, 1] = 0
        img[changind, 2] = 0
        img[img < 0] = 0

    else:
        img[:, :, 0] = np.log10(r_image)  # / max=1.0, dynrng=1e3,
        img[:, :, 1] = np.log10(g_image)
        img[:, :, 2] = np.log10(b_image)

        img -= np.log10(max / dynrng)
        img /= np.log10(dynrng)

        img[img > 1] = 1
        I = img
        val = img

    img[img < 0] = 0
    print "img min/max/mean " + str(img.min()) + "  " + str(
        img.max()) + "  " + str(img.mean())
    print " "

    del b_image, g_image, r_image, I, val
    gc.collect()

    img[img < 0] = 0
    return rp, img
Exemple #8
0
def return_synthetic_sdss_gri_img(filename, 
				lupton_alpha=0.5, lupton_Q=0.5, scale_min=1e-4, 
                                b_fac=0.7, g_fac=1.0, r_fac=1.3,
				**kwargs):

    seed=int(filename[filename.index('broadband_')+10:filename.index('.fits')])
    b_image, rp    = sunpy__synthetic_image.build_synthetic_image(filename, 'g_SDSS.res', 
				seed=seed,
				r_petro_kpc=None, 
				**kwargs)
    g_image, dummy = sunpy__synthetic_image.build_synthetic_image(filename, 'r_SDSS.res', 
				seed=seed,
				r_petro_kpc=rp, 
				**kwargs)
    r_image, dummy = sunpy__synthetic_image.build_synthetic_image(filename, 'i_SDSS.res', 
                                seed=seed,
				r_petro_kpc=rp, 
				**kwargs)

    n_pixels = r_image.shape[0]
    img = np.zeros((n_pixels, n_pixels, 3), dtype=float)
 
    b_image *= b_fac
    g_image *= g_fac
    r_image *= r_fac
 
    I = (r_image + g_image + b_image)/3
    val = np.arcsinh( lupton_alpha * lupton_Q * (I - scale_min))/lupton_Q
    I[ I < 1e-6 ] = 1e100		# from below, this effectively sets the pixel to 0

    img[:,:,0] = r_image * val / I
    img[:,:,1] = g_image * val / I
    img[:,:,2] = b_image * val / I

    maxrgbval = np.amax(img, axis=2)
 
    changeind = maxrgbval > 1.0
    img[changeind,0] = img[changeind,0]/maxrgbval[changeind]
    img[changeind,1] = img[changeind,1]/maxrgbval[changeind]
    img[changeind,2] = img[changeind,2]/maxrgbval[changeind]

    minrgbval = np.amin(img, axis=2)
    changeind = minrgbval < 0.0
    img[changeind,0] = 0
    img[changeind,1] = 0
    img[changeind,2] = 0

    changind = I < 0
    img[changind,0] = 0
    img[changind,1] = 0
    img[changind,2] = 0
    img[img<0] = 0

    print "img min/max/mean "+str(img.min())+"  "+str(img.max())+"  "+str(img.mean())
    print " "

    del b_image, g_image, r_image, I, val
    gc.collect()

    img[img<0] = 0
    return rp, img