construct_pixels_dataframe.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env: PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/home/ubuntu/im-photoz/Montage_v3.3/bin:/montage/bin\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "%env PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/home/ubuntu/im-photoz/Montage_v3.3/bin:/montage/bin\n",
    "\n",
    "from __future__ import absolute_import\n",
    "from __future__ import division\n",
    "from __future__ import print_function\n",
    "from __future__ import unicode_literals\n",
    "\n",
    "import os\n",
    "import shutil\n",
    "import requests\n",
    "import json\n",
    "import bz2\n",
    "import re\n",
    "import subprocess\n",
    "import math\n",
    "from time import sleep\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import montage_wrapper as mw\n",
    "from astropy.io import fits\n",
    "from astropy import wcs\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# SQL to get data\n",
    "def sample_one_sq_deg(ra, dec, d=1, n=500, dr=\"dr12\", timeout=60):\n",
    "    \n",
    "    url = \"http://skyserver.sdss.org/SkyserverWS/{}/SearchTools/SqlSearch\".format(dr)\n",
    "    payload = {\n",
    "        \"format\": \"json\",\n",
    "        \"cmd\": \"\"\"\n",
    "            SELECT TOP {0} spec.specObjID, phot.objID,\n",
    "                spec.ra, spec.dec,\n",
    "                spec.class,\n",
    "                spec.z, spec.zErr,\n",
    "                phot.rerun, phot.run, phot.camcol, phot.field,\n",
    "                phot.dered_u, phot.dered_g, phot.dered_r, phot.dered_i, phot.dered_z,\n",
    "                phot.psfMag_u, phot.psfMag_g, phot.psfMag_r, phot.psfMag_i, phot.psfMag_z,\n",
    "                phot.extinction_u, phot.extinction_g, phot.extinction_r, phot.extinction_i, phot.extinction_z\n",
    "            FROM SpecObjAll AS spec\n",
    "            JOIN PhotoObjAll AS phot\n",
    "            ON spec.specObjID = phot.specObjID\n",
    "            WHERE\n",
    "                phot.clean = 1\n",
    "                AND spec.zWarning = 0\n",
    "                AND spec.ra >= {1}\n",
    "                AND spec.ra < {2}\n",
    "                AND spec.dec >= {3}\n",
    "                AND spec.dec < {4}\n",
    "                AND phot.dered_r > 0 and phot.dered_r < 40\n",
    "                AND phot.expRad_r < 30\n",
    "                AND phot.deVRad_r < 30\n",
    "                AND spec.zErr < 0.1\n",
    "                AND spec.z < 2\n",
    "                AND spec.class = 'galaxy'\n",
    "            ORDER BY NEWID()\n",
    "        \"\"\".format(n, ra, ra + d, dec, dec + d).strip()\n",
    "    }\n",
    "    \n",
    "    try:\n",
    "        resp = requests.post(url, params=payload, timeout=timeout)\n",
    "    except requests.exceptions.RequestException as e:\n",
    "        print(e)\n",
    "        return None\n",
    "    \n",
    "    data = resp.json()[0]['Rows']\n",
    "    \n",
    "    df = pd.DataFrame(data)\n",
    "    \n",
    "    df[[\"specObjID\", \"objID\"]] = df[[\"specObjID\", \"objID\"]].astype(\"object\")\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Download images\n",
    "def fetch_fits(df, dirname=\"temp\"):\n",
    "\n",
    "    bands = [c for c in 'ugriz']\n",
    "\n",
    "    if not os.path.exists(dirname):\n",
    "        os.makedirs(dirname)\n",
    "\n",
    "    for i, r in df.iterrows():\n",
    "\n",
    "        url = \"http://data.sdss3.org/sas/dr12/boss/photoObj/frames/{0}/{1}/{2}/\".format(\n",
    "            r[\"rerun\"], r[\"run\"], r[\"camcol\"], r[\"field\"])\n",
    "\n",
    "        print(\"Downloading rerun: {}, run: {}, camcol: {}, field:{}\".format(\n",
    "            r[\"rerun\"], r[\"run\"], r[\"camcol\"], r[\"field\"]))\n",
    "    \n",
    "        for band in bands:\n",
    "\n",
    "            filename = \"frame-{4}-{1:06d}-{2}-{3:04d}.fits\".format(\n",
    "                r[\"rerun\"], r[\"run\"], r[\"camcol\"], r[\"field\"], band)\n",
    "            filepath = os.path.join(dirname, filename)\n",
    "            \n",
    "            if os.path.exists(filepath):\n",
    "                continue\n",
    "\n",
    "            for _ in range(10):\n",
    "                try:\n",
    "                    resp = requests.get(url + filename + \".bz2\")\n",
    "                except:\n",
    "                    sleep(1)\n",
    "                    continue\n",
    "                \n",
    "                if resp.status_code == 200:\n",
    "                    with open(filepath, \"wb\") as f:\n",
    "                        img = bz2.decompress(resp.content)\n",
    "                        f.write(img)\n",
    "                    break\n",
    "                else:\n",
    "                    sleep(1)\n",
    "                    continue\n",
    "\n",
    "            if not os.path.exists(filepath):\n",
    "                raise Exception"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_ref_list(df):\n",
    "\n",
    "    ref_images = []\n",
    "    \n",
    "    for row in df.iterrows():\n",
    "        r = row[1]\n",
    "        filename = \"frame-r-{1:06d}-{2}-{3:04d}.fits\".format(r[\"rerun\"], r[\"run\"], r[\"camcol\"], r[\"field\"])\n",
    "        ref_images.append(filename)\n",
    "\n",
    "    return ref_images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Montage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Montage: align images\n",
    "def align_images(images, frame_dir=\"temp\", registered_dir=\"temp/registered/\"):\n",
    "\n",
    "    if not os.path.exists(registered_dir):\n",
    "        os.makedirs(registered_dir)\n",
    "    \n",
    "    for image in images:\n",
    "\n",
    "        registered_path = [\n",
    "            os.path.join(registered_dir, image.replace(\"frame-r-\", \"registered-{}-\").format(b))\n",
    "            for b in \"ugriz\"\n",
    "            ]\n",
    "        \n",
    "        if all([os.path.exists(r) for r in registered_path]):\n",
    "            print(\"Skipping {}...\".format(image))\n",
    "            continue\n",
    "        else:\n",
    "            print(\"Processing {}...\".format(image))\n",
    "    \n",
    "        frame_path = [\n",
    "            os.path.join(frame_dir, image.replace(\"frame-r-\", \"frame-{}-\").format(b))\n",
    "            for b in \"ugriz\"\n",
    "            ]\n",
    "\n",
    "        header = os.path.join(\n",
    "            registered_dir,\n",
    "            image.replace(\"frame\", \"header\").replace(\".fits\", \".hdr\")\n",
    "            )\n",
    "\n",
    "        mw.commands.mGetHdr(os.path.join(frame_dir, image), header)\n",
    "        mw.reproject(\n",
    "            frame_path, registered_path,\n",
    "            header=header, silent_cleanup=True, common=True\n",
    "            )\n",
    "    \n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Convert ra and dec values to pixel positions\n",
    "def convert_catalog_to_pixels(df, dirname=\"temp/registered/\"):\n",
    "\n",
    "    if not os.path.exists(dirname):\n",
    "        os.makedirs(dirname)\n",
    "\n",
    "    pixels = []\n",
    "    fits_list = []\n",
    "\n",
    "    for i, r in df.iterrows():\n",
    "\n",
    "        fits_file = \"registered-r-{1:06d}-{2}-{3:04d}.fits\".format(\n",
    "            r[\"rerun\"], r[\"run\"], r[\"camcol\"], r[\"field\"])\n",
    "        fits_path = os.path.join(dirname, fits_file)\n",
    "            \n",
    "        hdulist = fits.open(fits_path)\n",
    "\n",
    "        w = wcs.WCS(hdulist[0].header, relax=False)\n",
    "        \n",
    "        px, py = w.all_world2pix(r[\"ra\"], r[\"dec\"], 1)\n",
    "\n",
    "        fits_list.append(fits_file)\n",
    "        pixels.append((i, px, py))\n",
    "\n",
    "    for i, fits_file in enumerate(fits_list):\n",
    "        ix, px, py = pixels[i]\n",
    "        pixel_list = fits_file.replace(\".fits\", \".list\")\n",
    "        pixel_path = os.path.join(dirname, pixel_list)\n",
    "        with open(pixel_path, \"a\") as fout:\n",
    "            fout.write(\"{} {} {}\\n\".format(ix, px, py))\n",
    "            \n",
    "    obj_pixels = pd.DataFrame(pixels, columns=['id', 'object_x_coord', 'object_y_coord']).drop('id', axis=1)\n",
    "    df_new = df.copy()\n",
    "    df_new['object_x_coord'] = obj_pixels['object_x_coord']\n",
    "    df_new['object_y_coord'] = obj_pixels['object_y_coord']\n",
    "\n",
    "    return df_new"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sextractor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting default.param\n"
     ]
    }
   ],
   "source": [
    "%%writefile default.param\n",
    "XMIN_IMAGE               Minimum x-coordinate among detected pixels                [pixel]\n",
    "YMIN_IMAGE               Minimum y-coordinate among detected pixels                [pixel]\n",
    "XMAX_IMAGE               Maximum x-coordinate among detected pixels                [pixel]\n",
    "YMAX_IMAGE               Maximum y-coordinate among detected pixels                [pixel]\n",
    "VECTOR_ASSOC(1)          #ASSOCiated parameter vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting default.sex\n"
     ]
    }
   ],
   "source": [
    "%%writefile default.sex\n",
    "#-------------------------------- Catalog ------------------------------------\n",
    " \n",
    "CATALOG_NAME     test.cat       # name of the output catalog\n",
    "CATALOG_TYPE     ASCII_HEAD     # NONE,ASCII,ASCII_HEAD, ASCII_SKYCAT,\n",
    "                                # ASCII_VOTABLE, FITS_1.0 or FITS_LDAC\n",
    "PARAMETERS_NAME  default.param  # name of the file containing catalog contents\n",
    " \n",
    "#------------------------------- Extraction ----------------------------------\n",
    " \n",
    "DETECT_TYPE      CCD            # CCD (linear) or PHOTO (with gamma correction)\n",
    "DETECT_MINAREA   3              # min. # of pixels above threshold\n",
    "DETECT_THRESH    1.5            # <sigmas> or <threshold>,<ZP> in mag.arcsec-2\n",
    "ANALYSIS_THRESH  1.5            # <sigmas> or <threshold>,<ZP> in mag.arcsec-2\n",
    " \n",
    "FILTER           Y              # apply filter for detection (Y or N)?\n",
    "FILTER_NAME      default.conv   # name of the file containing the filter\n",
    " \n",
    "DEBLEND_NTHRESH  32             # Number of deblending sub-thresholds\n",
    "DEBLEND_MINCONT  0.005          # Minimum contrast parameter for deblending\n",
    " \n",
    "CLEAN            Y              # Clean spurious detections? (Y or N)?\n",
    "CLEAN_PARAM      1.0            # Cleaning efficiency\n",
    " \n",
    "MASK_TYPE        CORRECT        # type of detection MASKing: can be one of\n",
    "                                # NONE, BLANK or CORRECT\n",
    "\n",
    "#------------------------------ Photometry -----------------------------------\n",
    " \n",
    "PHOT_APERTURES   5              # MAG_APER aperture diameter(s) in pixels\n",
    "PHOT_AUTOPARAMS  2.5, 3.5       # MAG_AUTO parameters: <Kron_fact>,<min_radius>\n",
    "PHOT_PETROPARAMS 2.0, 3.5       # MAG_PETRO parameters: <Petrosian_fact>,\n",
    "                                # <min_radius>\n",
    "\n",
    "SATUR_LEVEL      50000.0        # level (in ADUs) at which arises saturation\n",
    "SATUR_KEY        SATURATE       # keyword for saturation level (in ADUs)\n",
    " \n",
    "MAG_ZEROPOINT    0.0            # magnitude zero-point\n",
    "MAG_GAMMA        4.0            # gamma of emulsion (for photographic scans)\n",
    "GAIN             0.0            # detector gain in e-/ADU\n",
    "GAIN_KEY         GAIN           # keyword for detector gain in e-/ADU\n",
    "PIXEL_SCALE      1.0            # size of pixel in arcsec (0=use FITS WCS info)\n",
    " \n",
    "#------------------------- Star/Galaxy Separation ----------------------------\n",
    " \n",
    "SEEING_FWHM      1.2            # stellar FWHM in arcsec\n",
    "STARNNW_NAME     default.nnw    # Neural-Network_Weight table filename\n",
    " \n",
    "#------------------------------ Background -----------------------------------\n",
    " \n",
    "BACK_SIZE        64             # Background mesh: <size> or <width>,<height>\n",
    "BACK_FILTERSIZE  3              # Background filter: <size> or <width>,<height>\n",
    " \n",
    "BACKPHOTO_TYPE   GLOBAL         # can be GLOBAL or LOCAL\n",
    " \n",
    "#------------------------------ Check Image ----------------------------------\n",
    " \n",
    "CHECKIMAGE_TYPE  SEGMENTATION   # can be NONE, BACKGROUND, BACKGROUND_RMS,\n",
    "                                # MINIBACKGROUND, MINIBACK_RMS, -BACKGROUND,\n",
    "                                # FILTERED, OBJECTS, -OBJECTS, SEGMENTATION,\n",
    "                                # or APERTURES\n",
    "CHECKIMAGE_NAME  check.fits     # Filename for the check-image\n",
    " \n",
    "#--------------------- Memory (change with caution!) -------------------------\n",
    " \n",
    "MEMORY_OBJSTACK  3000           # number of objects in stack\n",
    "MEMORY_PIXSTACK  300000         # number of pixels in stack\n",
    "MEMORY_BUFSIZE   1024           # number of lines in buffer\n",
    " \n",
    "#----------------------------- Miscellaneous ---------------------------------\n",
    " \n",
    "VERBOSE_TYPE     NORMAL         # can be QUIET, NORMAL or FULL\n",
    "HEADER_SUFFIX    .head          # Filename extension for additional headers\n",
    "WRITE_XML        N              # Write XML file (Y/N)?\n",
    "XML_NAME         sex.xml        # Filename for XML output\n",
    "\n",
    "#----------------------------- ASSOC parameters ---------------------------------\n",
    "\n",
    "ASSOC_NAME       sky.list       # name of the ASCII file to ASSOCiate, the expected pixel \n",
    "                                # coordinates list given as [id, xpos, ypos]\n",
    "ASSOC_DATA       1              # columns of the data to replicate (0=all), replicate id\n",
    "                                # of the object in the SExtractor output file\n",
    "ASSOC_PARAMS     2,3            # columns of xpos,ypos[,mag] in the expected pixel\n",
    "                                # coordinates list\n",
    "ASSOC_RADIUS     2.0            # cross-matching radius (pixels)\n",
    "ASSOC_TYPE       NEAREST        # ASSOCiation method: FIRST, NEAREST, MEAN,\n",
    "                                # MAG_MEAN, SUM, MAG_SUM, MIN or MAX\n",
    "ASSOCSELEC_TYPE  MATCHED        # ASSOC selection type: ALL, MATCHED or -MATCHED"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def run_sex(filename, dirname=\"temp/registered/\"): # Run sextractor on one file\n",
    "    \n",
    "    fpath = os.path.join(dirname, filename)\n",
    "        \n",
    "    list_file = filename.replace(\".fits\", \".list\")\n",
    "    list_path = os.path.join(dirname, list_file)\n",
    "\n",
    "    config_file = filename.replace(\".fits\", \".sex\")\n",
    "\n",
    "    with open(\"default.sex\", \"r\") as default:\n",
    "        with open(config_file, \"w\") as temp:\n",
    "            for line in default:\n",
    "                line = re.sub(\n",
    "                    r\"^ASSOC_NAME\\s+sky.list\",\n",
    "                    \"ASSOC_NAME       {}\".format(list_file),\n",
    "                    line\n",
    "                )\n",
    "                temp.write(line)\n",
    "    \n",
    "    shutil.copy(list_path, os.getcwd())\n",
    "    \n",
    "    subprocess.call([\"sex\", \"-c\", config_file, fpath])\n",
    "\n",
    "    os.remove(config_file)\n",
    "    os.remove(os.path.join(os.getcwd(), list_file))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def nanomaggie_to_luptitude(array, band):\n",
    "    '''\n",
    "    Converts nanomaggies (flux) to luptitudes (magnitude).\n",
    "\n",
    "    http://www.sdss.org/dr12/algorithms/magnitudes/#asinh\n",
    "    http://arxiv.org/abs/astro-ph/9903081\n",
    "    '''\n",
    "    b = {\n",
    "        'u': 1.4e-10,\n",
    "        'g': 0.9e-10,\n",
    "        'r': 1.2e-10,\n",
    "        'i': 1.8e-10,\n",
    "        'z': 7.4e-10\n",
    "    }\n",
    "    nanomaggie = array * 1.0e-9 # fluxes are in nanomaggies\n",
    "\n",
    "    luptitude = -2.5 / np.log(10) * (np.arcsinh((nanomaggie / (2 * b[band]))) + np.log(b[band]))\n",
    "    \n",
    "    return luptitude"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_pixels_position(df, registered_all):\n",
    "    # Construct the new DataFrame with pixels of the stellar objects.\n",
    "    cat = pd.DataFrame()\n",
    "    pixels = pd.DataFrame()\n",
    "\n",
    "    remaining = len(registered_all)\n",
    "    print ('Total number of images to pass = {num}'.format(num=remaining))\n",
    "    for f in registered_all:\n",
    "        run_sex(f)\n",
    "    \n",
    "        # Get cat\n",
    "        try:\n",
    "            assoc = pd.read_csv(\n",
    "                \"test.cat\",\n",
    "                skiprows=5,\n",
    "                sep=\"\\s+\",\n",
    "                names=[\"xmin\", \"ymin\", \"xmax\", \"ymax\", \"match\"]\n",
    "            )\n",
    "            assoc[\"file\"] = f\n",
    "            cat = cat.append(assoc)\n",
    "        except:\n",
    "            pass\n",
    "    \n",
    "        # Get pixels, use r band as a reference\n",
    "        mask = fits.open('check.fits')  \n",
    "        m = mask[0].data\n",
    "        image = fits.open('temp/registered/'+f)\n",
    "        img = image[0].data\n",
    "    \n",
    "        # Get flux from all bands (ugriz)\n",
    "        flux = {}\n",
    "        flux_err = {}\n",
    "        bands = ['u', 'g', 'r', 'i', 'z']\n",
    "        for b in bands:\n",
    "            path = f.replace(\"-r-\", \"-{}-\".format(b))\n",
    "            image = fits.open('temp/registered/'+path)\n",
    "            flux[b] = image[0].data\n",
    "        f_u, f_g, f_r, f_i, f_z = flux.values()\n",
    "    \n",
    "        # Leave pixels that belong to objects only\n",
    "        img[m == 0] = 99 # Background\n",
    "        for objnum in np.unique(m):\n",
    "            if objnum != 0:\n",
    "\n",
    "                px, py = np.where(m == objnum)\n",
    "                    \n",
    "                u = f_u[m == objnum]\n",
    "                g = f_g[m == objnum]\n",
    "                r = f_r[m == objnum]\n",
    "                i = f_i[m == objnum]\n",
    "                z = f_z[m == objnum]\n",
    "\n",
    "                mat = assoc.loc[objnum-1]['match']\n",
    "                match = np.full(len(px), mat)\n",
    "                pix = pd.DataFrame({'match': match, 'pixel_x_coord': px, 'pixel_y_coord': py,\n",
    "                                    'flux_u': u, 'flux_g': g, 'flux_r':r, 'flux_i':i, 'flux_z':z,\n",
    "                                    'flux_err_u': u, 'flux_err_g': g, 'flux_err_r':r, 'flux_err_i':i, 'flux_err_z':z})\n",
    "                pixels = pixels.append(pix)\n",
    "            \n",
    "        remaining -= 1\n",
    "        print ('Remaining number of images = {num}'.format(num=remaining))\n",
    "    \n",
    "    print ('Matching starts.')\n",
    "    if len(cat) > 0:\n",
    "        cat[\"class\"] = df.ix[cat[\"match\"], \"class\"].values\n",
    "        cat[\"objID\"] = df.ix[cat[\"match\"], \"objID\"].values\n",
    "    if len(pixels) > 0:\n",
    "        pixels[\"objID\"] = df.ix[pixels[\"match\"], \"objID\"].values\n",
    "        pixels[\"class\"] = df.ix[pixels[\"match\"], \"class\"].values \n",
    "        pixels['object_x_coord'] = df.ix[pixels[\"match\"], 'object_x_coord'].values.astype(float)\n",
    "        pixels['object_y_coord'] = df.ix[pixels[\"match\"], 'object_y_coord'].values.astype(float)\n",
    "        pixels[\"z\"] = df.ix[pixels[\"match\"], \"z\"].values\n",
    "        pixels[\"zErr\"] = df.ix[pixels[\"match\"], \"zErr\"].values\n",
    "        pixels[\"extinction_u\"] = df.ix[pixels[\"match\"],\"extinction_u\"].values\n",
    "        pixels[\"extinction_g\"] = df.ix[pixels[\"match\"],\"extinction_g\"].values\n",
    "        pixels[\"extinction_r\"] = df.ix[pixels[\"match\"],\"extinction_r\"].values\n",
    "        pixels[\"extinction_i\"] = df.ix[pixels[\"match\"],\"extinction_i\"].values\n",
    "        pixels[\"extinction_z\"] = df.ix[pixels[\"match\"],\"extinction_z\"].values\n",
    "        if not \"pixelID\" in pixels.columns:\n",
    "            pixels.insert(loc=0, value = np.arange(0, pixels['pixel_x_coord'].count()), column = \"pixelID\")\n",
    "    \n",
    "    # Calculate distance\n",
    "    if len(pixels) > 0:\n",
    "        x_pixels = np.array(pixels.pixel_x_coord)\n",
    "        x_obj_pixels = np.array(pixels.object_x_coord)\n",
    "        y_pixels = np.array(pixels.pixel_y_coord)\n",
    "        y_obj_pixels = np.array(pixels.object_y_coord)\n",
    "        pixels[\"distance_to_obj\"] = ((x_pixels-x_obj_pixels)**2+(y_pixels-y_obj_pixels)**2)**0.5\n",
    "    \n",
    "    # Change fluxes from nanomaggie to luptitude\n",
    "    pixels[\"lup_u\"] = nanomaggie_to_luptitude(np.array(pixels.flux_u), 'u')\n",
    "    pixels[\"lup_g\"] = nanomaggie_to_luptitude(np.array(pixels.flux_g), 'g')\n",
    "    pixels[\"lup_r\"] = nanomaggie_to_luptitude(np.array(pixels.flux_r), 'r')\n",
    "    pixels[\"lup_i\"] = nanomaggie_to_luptitude(np.array(pixels.flux_i), 'i')\n",
    "    pixels[\"lup_z\"] = nanomaggie_to_luptitude(np.array(pixels.flux_z), 'z')\n",
    "    \n",
    "    print ('The job is finished.')\n",
    "    \n",
    "    return cat, pixels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def main(ra, dec):\n",
    "    df = sample_one_sq_deg(ra, dec, d=1, n=500)\n",
    "    print(len(df))\n",
    "    fetch_fits(df)\n",
    "    ref_images = get_ref_list(df)\n",
    "    align_images(ref_images)\n",
    "    objects = convert_catalog_to_pixels(df)\n",
    "    registered_all = [f.replace(\"frame-\", \"registered-\") for f in ref_images]\n",
    "    cat, pixels = get_pixels_position(objects, registered_all)\n",
    "    pixels.to_csv(\"data/pixels/{ra},{dec}-pixels.csv\".format(ra=ra, dec=dec), index=False)\n",
    "    # objects.to_csv(\"data/objects/{ra},{dec}-objects.csv\".format(ra=ra, dec=dec), index=False)\n",
    "    shutil.rmtree(\"temp/\")\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}