Exemplo n.º 1
0
def make_rgb(imlist, wtlist, nonlinear=0.12, scale=0.0005):
    """
    make an rgb image using the input images and weights
    """
    import images

    # relative_scales = np.array([1.1, 1.0, 2.0])
    relative_scales = np.array([1.0, 1.0, 2.0])

    scales = scale * relative_scales

    noise_fac = 0.1
    rminval = noise_fac * np.sqrt(1 / wtlist[2][0, 0])
    gminval = noise_fac * np.sqrt(1 / wtlist[1][0, 0])
    bminval = noise_fac * np.sqrt(1 / wtlist[0][0, 0])

    minval = min(rminval, gminval, bminval)
    minval = 0

    r = imlist[2].clip(min=minval)
    g = imlist[1].clip(min=minval)
    b = imlist[0].clip(min=minval)

    rgb = images.get_color_image(
        r.transpose(),
        g.transpose(),
        b.transpose(),
        scales=scales,
        nonlinear=nonlinear,
    )
    rgb.clip(max=1.0, out=rgb)
    return rgb
Exemplo n.º 2
0
def fake_rgb(mbobs):
    """
    fake rgb from single band
    """
    import images

    #SCALE=.015*np.sqrt(2.0)
    #SCALE=0.001
    SCALE = 1.0
    relative_scales = np.array([1.0, 1.0, 1.0])
    scales = SCALE * relative_scales

    r = mbobs[0][0].image
    g = r
    b = r

    rgb = images.get_color_image(
        r.transpose(),
        g.transpose(),
        b.transpose(),
        #scales=scales,
        #nonlinear=0.12,
        nonlinear=0.07,
    )
    return rgb
Exemplo n.º 3
0
def make_frame_jpg(**keys):
    from PIL import Image
    from numpy import array, flipud
    import sdsspy
    import esutil as eu
    import images
    #import biggles

    g,gh=sdsspy.read('frame', filter='g', header=True, **keys)
    r,rh=sdsspy.read('frame', filter='r', header=True, **keys)
    i,ih=sdsspy.read('frame', filter='i', header=True, **keys)

    gwcs=eu.wcsutil.WCS(gh)
    rwcs=eu.wcsutil.WCS(rh)
    iwcs=eu.wcsutil.WCS(ih)

    # convert r-band center to ra,dec
    rowcen_r=r.shape[0]/2.
    colcen_r=r.shape[1]/2.

    racen_r,deccen_r = rwcs.image2sky(colcen_r, rowcen_r)

    # now see where that falls in the g and i images
    gcol,grow=gwcs.sky2image(racen_r, deccen_r)
    icol,irow=iwcs.sky2image(racen_r, deccen_r)

    gshift=[rowcen_r-grow, colcen_r-gcol]
    ishift=[rowcen_r-irow, colcen_r-icol]

    g = shift_image(g, gshift)
    i = shift_image(i, ishift)

    rescale=0.4
    scales= rescale*array([5., 6.5, 9.])
    nonlinear=0.15

    colorim=images.get_color_image(i, r, g, 
                                   scales=scales,
                                   nonlinear=nonlinear,
                                   satval=30.)


    fname=get_jpg_path(**keys)
    print 'writing:',fname
    dname=os.path.dirname(fname)
    if not os.path.exists(dname):
        print 'making dirs:',dname
        os.makedirs(dname)

    #colorim = (colorim*255).astype('u1')
    colorim = images.bytescale(colorim)
    colorim=flipud(colorim)

    pim=Image.fromarray(colorim)
    pim.save(fname, quality=90)
Exemplo n.º 4
0
def make_rgb_old(r, g, b):
    import images

    maxval = max(r.max(), g.max(), b.max())
    scales = [1.0 / maxval] * 3
    rgb = images.get_color_image(
        r.transpose(),
        g.transpose(),
        b.transpose(),
        scales=scales,
        nonlinear=0.1,
    )

    return rgb
Exemplo n.º 5
0
    def make_image(self):
        import images

        self._make_imlist()

        scales=self._get_scales()

        print("using satval:",self.satval)
        print('getting color image')
        imlist=self.imlist
        colorim=images.get_color_image(imlist[2].image,
                                       imlist[1].image,
                                       imlist[0].image,
                                       scales=scales,
                                       nonlinear=NONLINEAR,
                                       satval=self.satval)

        print('bytescaling')
        colorim = images.bytescale(colorim)

        self.colorim=colorim
Exemplo n.º 6
0
def make_rgb(mbobs):
    import images

    #SCALE=.015*np.sqrt(2.0)
    SCALE = 0.01
    # lsst
    #SCALE=0.0005
    #relative_scales = np.array([1.00, 1.2, 2.0])
    relative_scales = np.array([1.00, 1.0, 2.0])

    scales = SCALE * relative_scales

    r = mbobs[2][0].image
    g = mbobs[1][0].image
    b = mbobs[0][0].image

    rgb = images.get_color_image(
        r.transpose(),
        g.transpose(),
        b.transpose(),
        scales=scales,
        nonlinear=0.12,
    )
    return rgb
Exemplo n.º 7
0
    def make_image(self):
        """
        create the rgb image
        """
        import images

        self._make_imlist()

        scales = self._get_scales()

        print("using satval:", self.satval)
        print('getting color image')
        imlist = self.imlist
        colorim = images.get_color_image(imlist[2].image,
                                         imlist[1].image,
                                         imlist[0].image,
                                         scales=scales,
                                         nonlinear=NONLINEAR,
                                         satval=self.satval)

        print('bytescaling')
        colorim = images.bytescale(colorim)

        self.colorim = colorim
Exemplo n.º 8
0
def test(ntrial=1, dim=2000, show=False):
    import galsim
    import biggles
    import images

    rng = np.random.RandomState()

    nobj_per = 4
    nknots = 100
    knot_flux_frac = 0.001
    nknots_low, nknots_high = 1, 100

    nband = 3
    noises = [0.0005, 0.001, 0.0015]
    scale = 0.263

    psf = galsim.Gaussian(fwhm=0.9)
    dims = 64, 64
    flux_low, flux_high = 0.5, 1.5
    r50_low, r50_high = 0.1, 2.0

    fracdev_low, fracdev_high = 0.001, 0.99

    bulge_colors = np.array([0.5, 1.0, 1.5])
    disk_colors = np.array([1.25, 1.0, 0.75])
    knots_colors = np.array([1.5, 1.0, 0.5])

    sigma = dims[0]/2.0/4.0*scale
    maxrad = dims[0]/2.0/2.0 * scale

    tm0 = time.time()
    nobj_meas = 0

    for trial in range(ntrial):
        print("trial: %d/%d" % (trial+1, ntrial))
        all_band_obj = []
        for i in range(nobj_per):

            nknots = int(rng.uniform(low=nknots_low, high=nknots_high))

            r50 = rng.uniform(low=r50_low, high=r50_high)
            flux = rng.uniform(low=flux_low, high=flux_high)

            dx, dy = rng.normal(scale=sigma, size=2).clip(
                min=-maxrad,
                max=maxrad,
            )

            g1d, g2d = rng.normal(scale=0.2, size=2).clip(max=0.5)
            g1b = 0.5*g1d+rng.normal(scale=0.02)
            g2b = 0.5*g2d+rng.normal(scale=0.02)

            fracdev = rng.uniform(low=fracdev_low, high=fracdev_high)

            flux_bulge = fracdev*flux
            flux_disk = (1-fracdev)*flux
            flux_knots = nknots*knot_flux_frac*flux_disk
            print("fracdev:", fracdev, "nknots:", nknots)

            bulge_obj = galsim.DeVaucouleurs(
                half_light_radius=r50
            ).shear(g1=g1b, g2=g2b)

            disk_obj = galsim.Exponential(
                half_light_radius=r50
            ).shear(g1=g1d, g2=g2d)

            knots_obj = galsim.RandomWalk(
                npoints=nknots,
                profile=disk_obj,
            )  # .shear(g1=g1d, g2=g2d)

            band_objs = []
            for band in range(nband):
                band_disk = disk_obj.withFlux(flux_disk*disk_colors[band])
                band_bulge = bulge_obj.withFlux(flux_bulge*bulge_colors[band])
                band_knots = knots_obj.withFlux(flux_knots*knots_colors[band])

                obj = galsim.Sum(band_disk, band_bulge, band_knots).shift(
                    dx=dx,
                    dy=dy,
                )
                obj = galsim.Convolve(obj, psf)
                band_objs.append(obj)

            all_band_obj.append(band_objs)

        jacob = ngmix.DiagonalJacobian(
            row=0,
            col=0,
            scale=scale,
        )
        wcs = jacob.get_galsim_wcs()
        psfim = psf.drawImage(wcs=wcs).array
        psf_obs = get_psf_obs(psfim, jacob)

        dlist = []
        for band in range(nband):
            band_objects = [o[band] for o in all_band_obj]
            obj = galsim.Sum(band_objects)

            im = obj.drawImage(nx=dims[1], ny=dims[0], wcs=wcs).array
            im = obj.drawImage(nx=dims[1], ny=dims[0], scale=scale).array

            im += rng.normal(scale=noises[band], size=im.shape)
            wt = im*0 + 1.0/noises[band]**2

            dlist.append(
                dict(
                    image=im,
                    weight=wt,
                    wcs=wcs,
                )
            )

        mer = MEDSifier(dlist)

        mg = mer.get_meds(0)
        mr = mer.get_meds(1)
        mi = mer.get_meds(2)
        nobj = mg.size
        print("        found", nobj, "objects")
        nobj_meas += nobj

        list_of_obs = []
        for i in range(nobj):

            gobslist = mg.get_obslist(i, weight_type='uberseg')
            robslist = mr.get_obslist(i, weight_type='uberseg')
            iobslist = mi.get_obslist(i, weight_type='uberseg')
            mbo = ngmix.MultiBandObsList()
            mbo.append(gobslist)
            mbo.append(robslist)
            mbo.append(iobslist)

            list_of_obs.append(mbo)

        for mbo in list_of_obs:
            for obslist in mbo:
                for obs in obslist:
                    obs.set_psf(psf_obs)

        prior = moflib.get_mof_prior(list_of_obs, "bdf", rng)
        mof_fitter = moflib.MOFStamps(
            list_of_obs,
            "bdf",
            prior=prior,
        )
        band = 2
        guess = moflib.get_stamp_guesses(list_of_obs, band, "bdf", rng)
        mof_fitter.go(guess)

        if show:
            # corrected images
            tab = biggles.Table(1, 2)
            rgb = images.get_color_image(
                dlist[2]['image'].transpose(),
                dlist[1]['image'].transpose(),
                dlist[0]['image'].transpose(),
                nonlinear=0.1,
            )
            rgb *= 1.0/rgb.max()

            tab[0, 0] = images.view_mosaic(
                [rgb,
                 mer.seg,
                 mer.detim],
                titles=['image', 'seg', 'detim'],
                show=False,
                # dims=[dim, dim],
            )

            imlist = []
            for iobj, mobs in enumerate(list_of_obs):
                cmobs = mof_fitter.make_corrected_obs(iobj)

                gim = images.make_combined_mosaic(
                    [mobs[0][0].image, cmobs[0][0].image],
                )
                rim = images.make_combined_mosaic(
                    [mobs[1][0].image, cmobs[1][0].image],
                )
                iim = images.make_combined_mosaic(
                    [mobs[2][0].image, cmobs[2][0].image],
                )

                rgb = images.get_color_image(
                    iim.transpose(),
                    rim.transpose(),
                    gim.transpose(),
                    nonlinear=0.1,
                )
                rgb *= 1.0/rgb.max()
                imlist.append(rgb)

            plt = images.view_mosaic(imlist, show=False)
            tab[0, 1] = plt
            tab.show(width=dim*2, height=dim)

            if ntrial > 1:
                if 'q' == input("hit a key: "):
                    return

    total_time = time.time()-tm0
    print("time per group:", total_time/ntrial)
    print("time per object:", total_time/nobj_meas)
Exemplo n.º 9
0
def view_atlas(**keys):
    """
    View atlas images for the input object

    parameters
    ----------
    cat: optional
        A full structure with run,rerun,camcol,field,id
    run: optional
        Run id
    rerun: optional
        rerun id
    camcol: optional
        camcol id
    field: opt
        field id
    id: opt
        id in field
    band: optional
        Only display this band

    shift:
        Apply sub-pixel astronometric shifts, default False
    """
    import images
    import biggles
    import sdsspy

    biggles.configure( 'default', 'fontsize_min', 1)

    band=keys.get('band',None)
    cat=keys.get('cat',None)
    show=keys.get('show',True)
    color=keys.get('color',False)
    shift=keys.get('shift',False)

    idinfo=get_id_info(**keys)

    imdict=read_atlas(**idinfo)

    nonlinear=keys.get('nonlinear', _default_nonlinear)

    if band is not None:
        bnum=sdsspy.util.FILTERNUM[band]
        bchar=sdsspy.util.FILTERCHAR[band]

        idinfo['bchar']=bchar
        title='%(run)06d-%(camcol)d-%(field)04d-%(id)05d-%(bchar)s' % idinfo
        im=imdict['images'][bnum]

        plt=images.view(im, nonlinear=nonlinear,show=False)

        plt.title=title
        lab=biggles.PlotLabel(0.9,0.9,bchar,color='yellow')
        plt.add(lab)
        if show:
            plt.show()
        return plt
    elif color:
        img=imdict['images'][1].transpose()
        imr=imdict['images'][2].transpose()
        imi=imdict['images'][3].transpose()

        if shift:
            img,imi=shift_images(imdict, img, imi)

        colorim=images.get_color_image(imi,imr,img,
                                       satval=30.,
                                       nonlinear=nonlinear)

        s=imdict['images'][0].shape
        ranges = ((-0.5, -0.5), (s[1]-0.5, s[0]-0.5))

        d = biggles.Density(colorim, ranges)

        plt=biggles.FramedPlot()
        plt.add(d)
        plt.aspect_ratio=s[0]/float(s[1])
        title='%(run)06d-%(camcol)d-%(field)04d-%(id)05d' % idinfo
        plt.title=title
        if show:
            plt.show()
        return plt


    imslist=scale_image_list(imdict['images'], nonlinear)

    nrow=2
    ncol=3
    plt=biggles.FramedArray(nrow,ncol)
    title='%(run)06d-%(camcol)d-%(field)04d-%(id)05d' % idinfo
    plt.title=title

    s=imslist[0].shape
    plt.aspect_ratio = s[0]/float(s[1])*2./3.

    for i in xrange(5):
        bchar=sdsspy.util.FILTERCHAR[i]
        row=i/ncol
        col=i % ncol

        im=imslist[i]
        s=im.shape

        im = im.transpose()
        ranges = ((-0.5, -0.5), (s[1]-0.5, s[0]-0.5))

        d = biggles.Density(im, ranges)

        #labs=get_shaded_label(0.9,0.9,bchar)
        lab=biggles.PlotLabel(0.9,0.9,bchar,color='yellow')
        plt[row,col].add(d)
        plt[row,col].add(lab)

    if show:
        plt.show()
    return plt 
Exemplo n.º 10
0
def view_family(**keys):
    """
    If cat/index not sent the data will be read if the id info is
    sent
    """
    import sdsspy
    import biggles
    import images
    from sdsspy.atlas.atlas import NoAtlasImageError

    band=keys.get('band',None)
    color=keys.get('color',False)
    show=keys.get('show',True)
    nonlinear=keys.get('nonlinear', _default_nonlinear)
    minval=keys.get('min',1.0)

    biggles.configure( 'default', 'fontsize_min', 0.75)
    if band is None and not color:
        raise ValueError("send band= or color=True")

    fam,cat,index=read_family(**keys)

    if band is not None:
        bnum=sdsspy.util.FILTERNUM[band]
        bchar=sdsspy.util.FILTERCHAR[band]

    children=fam.get_children()
    parent=fam.get_parent()
    grandparent=fam.get_grandparent()
    
    main_title='%(run)06d-%(camcol)d-%(field)04d-%(id)05d' % cat[index]
    if band is not None:
        main_title += ' %s' % bchar

    run=cat['run'][index]
    camcol=cat['camcol'][index]
    field=cat['field'][index]
    rerun=cat['rerun'][index]

    imlist=[]
    titles=[]
    if grandparent.size > 0:
        try:
            imd=read_atlas(run=run,camcol=camcol,field=field,
                           rerun=rerun, id=cat['id'][grandparent[0]])
            if band is not None:
                im=imd['images'][bnum]
                imlist.append(im)
            else:
                imlist.append(imd)

            title='grandparent %d' % cat['id'][grandparent[0]]
            titles.append(title)
        except NoAtlasImageError:
            pass

    if parent.size > 0:
        try:
            imd=read_atlas(run=run,camcol=camcol,field=field,
                           rerun=rerun, id=cat['id'][parent[0]])
            if band is not None:
                im=imd['images'][bnum]
                imlist.append(im)
            else:
                imlist.append(imd)


            title='parent %d' % cat['id'][parent[0]]
            titles.append(title)
        except NoAtlasImageError:
            pass

    for i in xrange(children.size):
        try:
            imd=read_atlas(run=run,camcol=camcol,field=field,
                           rerun=rerun, id=cat['id'][children[i]])
            if band is not None:
                im=imd['images'][bnum]
                imlist.append(im)
            else:
                imlist.append(imd)

            title='child %d' % cat['id'][children[i]]
            titles.append(title)
        except NoAtlasImageError:
            pass

    ntot = len(imlist)
    if ntot == 0:
        raise NoAtlasImageError("none of the objects had atlas images")

    if band is not None:
        imslist=scale_image_list(imlist, nonlinear)
        imslist=[im.transpose() for im in imslist]
    else:
        imslist=[]
        for imd in imlist:
            img=imd['images'][1].transpose()
            imr=imd['images'][2].transpose()
            imi=imd['images'][3].transpose()

            cim=images.get_color_image(imi,imr,img,
                                       satval=30.,
                                       nonlinear=nonlinear)

            imslist.append(cim)

    nrow,ncol=get_family_grid(ntot)
    plt=biggles.FramedArray(nrow,ncol)
    s=imslist[0].shape
    plt.aspect_ratio = s[1]/float(s[0])*nrow/float(ncol)
    plt.title=main_title
    lcolor='gray75'
    for i in xrange(ntot):
        im=imslist[i]
        row=i/ncol
        col=i % ncol

        # transposed shape
        s=im.shape
        ranges = ((-0.5, -0.5), (s[0]-0.5, s[1]-0.5))
        d = biggles.Density(im, ranges)

        plt[row,col].add(d)

        lab=biggles.PlotLabel(0.075,0.9,titles[i],halign='left',
                              color=lcolor)
        plt[row,col].add(lab)

    if show:
        plt.show()

    return plt