hawc_hal.flat_sky_projection.FlatSkyProjection._oversample() - Code Metrics - Inspection of "Fixing energy fitting" - giacomov/hawc_hal - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 573345...9597ff )

by Giacomo

created 2018-07-06 21:54 UTC

FlatSkyProjection._oversample() A

↳ Parent: hawc_hal.flat_sky_projection

Complexity

Conditions

Size

Total Lines	21
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	10
dl	0
loc	21
rs	9.9
c	0
b	0
f	0
cc	2
nop	2

from astropy.io import fits
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
from astropy.wcs import WCS

from astropy.wcs.utils import proj_plane_pixel_area

import numpy as np


from util import cartesian

from psf_fast.sphere_dist import sphere_dist



_fits_header = """

NAXIS   =                    2
NAXIS1  =                   %i
NAXIS2  =                   %i
CTYPE1  = 'RA---AIT'
CRPIX1  =                   %i
CRVAL1  =                   %s
CDELT1  =                  -%f
CUNIT1  = 'deg     '
CTYPE2  = 'DEC--AIT'
CRPIX2  =                   %i
CRVAL2  =                   %s
CDELT2  =                   %f
CUNIT2  = 'deg     '
COORDSYS= '%s'
"""


def _get_header(ra, dec, pixel_size, coordsys, h, w):


    assert 0 <= ra <= 360

    header = fits.Header.fromstring(_fits_header % (h, w,
                                                    h / 2, ra, pixel_size,
                                                    w / 2, dec, pixel_size,
                                                    coordsys),
                                    sep='\n')

    return header


def _get_all_ra_dec(input_wcs, h, w):


    # An array of all the possible permutation of (i,j) for i=0..999 and j=0..999

    xx = np.arange(0.5, h + 0.5, 1, dtype=np.int16)

    yy = np.arange(0.5, w + 0.5, 1, dtype=np.int16)


    _ij_grid = cartesian((xx,
                          yy))

    # Convert pixel coordinates to world coordinates
    world = input_wcs.all_pix2world(_ij_grid, 0, ra_dec_order=True)

    return world[:, 0], world[:, 1]


class FlatSkyProjection(object):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""

    def __init__(self, ra_center, dec_center, pixel_size_deg, npix_height, npix_width, oversample=True):


        assert npix_height % 2 == 0, "Number of height pixels must be even"
        assert npix_width % 2 == 0, "Number of width pixels must be even"

        if isinstance(npix_height, float):

            assert npix_height.is_integer(), "This is a bug"

        if isinstance(npix_width, float):

            assert npix_width.is_integer(), "This is a bug"

        self._npix_height = int(npix_height)
        self._npix_width = int(npix_width)

        assert 0 <= ra_center <= 360.0, "Right Ascension must be between 0 and 360"
        assert -90.0 <= dec_center <= 90.0, "Declination must be between -90.0 and 90.0"

        self._ra_center = float(ra_center)
        self._dec_center = float(dec_center)

        self._pixel_size_deg = float(pixel_size_deg)

        # Build projection, i.e., a World Coordinate System object

        self._wcs = WCS(_get_header(ra_center, dec_center, pixel_size_deg, 'icrs', npix_height, npix_width))


        # Pre-compute all R.A., Decs
        self._ras, self._decs = _get_all_ra_dec(self._wcs, npix_height, npix_width)

        # Make sure we have the right amount of coordinates
        assert self._ras.shape[0] == self._decs.shape[0]
        assert self._ras.shape[0] == npix_width * npix_height

        # Pre-compute pixel area
        self._pixel_area= proj_plane_pixel_area(self._wcs)


        # Pre-compute an oversampled version to be used for PSF integration
        if oversample and pixel_size_deg > 0.025:

            self._oversampled, self._oversample_factor = self._oversample(new_pixel_size=0.025)

        else:

            self._oversampled = self
            self._oversample_factor = 1

        # Cache for angular distances from a point (see get_spherical_distances_from)
        self._distance_cache = {}

    def _oversample(self, new_pixel_size):
        """Return a new instance oversampled by the provided factor"""

        # Compute the oversampling factor (as a float because we need it for the division down)
        factor = float(np.ceil(self._pixel_size_deg / new_pixel_size))

        if factor <= 1:


            # The projection is already with a smaller pixel size than the oversampled version
            # No need to oversample
            return self, 1

        else:

            new_fp = FlatSkyProjection(self._ra_center, self._dec_center,
                                       self._pixel_size_deg / factor,
                                       self._npix_height * factor,
                                       self._npix_width * factor,
                                       oversample=False)

            return new_fp, int(factor)

    @property
    def oversampled(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self._oversampled

    @property
    def oversample_factor(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self._oversample_factor

    @property
    def ras(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self._ras

    @property
    def decs(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self._decs

    @property
    def ra_center(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self._ra_center

    @property
    def dec_center(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self._dec_center

    @property
    def pixel_size(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self._pixel_size_deg

    @property
    def wcs(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self._wcs

    @property
    def npix_height(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self._npix_height

    @property
    def npix_width(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self._npix_width

    @property
    def project_plane_pixel_area(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        return self._pixel_area

    def get_spherical_distances_from(self, ra, dec, cutout_radius):

        """
        Returns the distances for all points in this grid from the given point

        :param ra:
        :param dec:
        :param cutout_radius: do not consider elements beyond this radius (NOTE: we use a planar approximation on

        purpose, to make things fast, so the cut is not precise)
        :return: (angular distances of selected points from (ra, dec), selection indexes)
        """

        # This is typically used sequentially on different energy bins, so we cache the result and re-use it

        # if we already computed it

        key = (ra, dec, cutout_radius, self.ras.shape[0], self.decs.shape[0])

        if key not in self._distance_cache:

            # In order to gain speed, we use a planar approximation (instead of using the harversine formula we assume

            # plane geometry). This gets more and more unprecise the large the cutout radius, but we do not care here


            selection_idx = (((ra - self.ras)**2 + (dec - self.decs)**2) <= (1.2*cutout_radius)**2)  # type: np.ndarray


            ds = sphere_dist(ra, dec, self.ras[selection_idx], self.decs[selection_idx])


            # Refine selection by putting to False all elements in the mask at a distance larger than the cutout

            # radius
            fine_selection_idx = (ds <= cutout_radius)
            selection_idx[selection_idx.nonzero()[0][~fine_selection_idx]] = False

            # This is to make sure we only keep cached the last result, and the dictionary does not grow indefinitely

            self._distance_cache = {}

            self._distance_cache[key] = (ds[fine_selection_idx], selection_idx)

        return self._distance_cache[key]




1			from astropy.io import fits
			0 ignored issues – show Coding Style introduced 2018-06-02 00:48 UTC by Report Bug Copy Issue Report This module should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history... introduced 2018-06-02 00:48 UTC by Report Bug Copy Issue Report Unable to import 'astropy.io' Loading history...
2			from astropy.wcs import WCS
			0 ignored issues – show introduced 2018-06-02 00:48 UTC by Report Bug Copy Issue Report Unable to import 'astropy.wcs' Loading history...
3			from astropy.wcs.utils import proj_plane_pixel_area
			0 ignored issues – show introduced 2018-06-02 00:48 UTC by Report Bug Copy Issue Report Unable to import 'astropy.wcs.utils' Loading history...
4			import numpy as np
			0 ignored issues – show introduced 2018-06-02 00:48 UTC by Report Bug Copy Issue Report Unable to import 'numpy' Loading history...
5
6			from util import cartesian
			0 ignored issues – show Coding Style introduced 2018-07-06 22:00 UTC by Report Bug Copy Issue Report Relative import 'util', should be 'hawc_hal.util' Loading history...
7			from psf_fast.sphere_dist import sphere_dist
			0 ignored issues – show Coding Style introduced 2018-07-06 22:00 UTC by Report Bug Copy Issue Report Relative import 'psf_fast.sphere_dist', should be 'hawc_hal.psf_fast.sphere_dist' Loading history...
8
9
10			_fits_header = """
			0 ignored issues – show Coding Style Naming introduced 2018-07-06 22:00 UTC by Report Bug Copy Issue Report The name `_fits_header` does not conform to the constant naming conventions (`(([A-Z_][A-Z0-9_])\|(__.__))$`). This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history...
11			NAXIS = 2
12			NAXIS1 = %i
13			NAXIS2 = %i
14			CTYPE1 = 'RA---AIT'
15			CRPIX1 = %i
16			CRVAL1 = %s
17			CDELT1 = -%f
18			CUNIT1 = 'deg '
19			CTYPE2 = 'DEC--AIT'
20			CRPIX2 = %i
21			CRVAL2 = %s
22			CDELT2 = %f
23			CUNIT2 = 'deg '
24			COORDSYS= '%s'
25			"""
26
27
28			def _get_header(ra, dec, pixel_size, coordsys, h, w):
			0 ignored issues – show Coding Style Naming introduced 2018-06-02 00:48 UTC by Report Bug Copy Issue Report The name `ra` does not conform to the argument naming conventions (`(([a-z][a-z0-9_]{2,30})\|(_[a-z0-9_]))$`). This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history... Coding Style Naming introduced 2018-06-02 00:48 UTC by Report Bug Copy Issue Report The name `h` does not conform to the argument naming conventions (`(([a-z][a-z0-9_]{2,30})\|(_[a-z0-9_]))$`). This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history... Coding Style Naming introduced 2018-06-02 00:48 UTC by Report Bug Copy Issue Report The name `w` does not conform to the argument naming conventions (`(([a-z][a-z0-9_]{2,30})\|(_[a-z0-9_]*))$`). This check looks for invalid names for a range of different identifiers. You can set regular expressions to which the identifiers must conform if the defaults do not match your requirements. If your project includes a Pylint configuration file, the settings contained in that file take precedence. To find out more about Pylint, please refer to their site. Loading history... best-practice introduced 2018-06-02 00:48 UTC by Report Bug Copy Issue Report Too many arguments (6/5) Loading history...
29
30			assert 0 <= ra <= 360
31
32			header = fits.Header.fromstring(_fits_header % (h, w,

giacomov / hawc_hal

Push — master ( 573345...9597ff )

FlatSkyProjection._oversample() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like